diff options
Diffstat (limited to 'src')
96 files changed, 22597 insertions, 13491 deletions
diff --git a/src/char/Makefile.in b/src/char/Makefile.in index 456f7e9d2..fe40621fb 100644 --- a/src/char/Makefile.in +++ b/src/char/Makefile.in @@ -23,7 +23,7 @@ CONFIG_D = ../config CONFIG_H = $(wildcard $(CONFIG_D)/*.h) $(wildcard $(CONFIG_D)/*/*.h) COMMON_D = ../common -COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) +COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) ../plugins/HPMHooking.h SYSINFO_INC = $(COMMON_D)/sysinfo.inc COMMON_INCLUDE = -I.. diff --git a/src/char/char.c b/src/char/char.c index 929473e33..5f92e37bf 100644 --- a/src/char/char.c +++ b/src/char/char.c @@ -62,6 +62,14 @@ #include <stdlib.h> #include <sys/types.h> +#if MAX_MAP_SERVERS > 1 +# ifdef _MSC_VER +# pragma message("WARNING: your settings allow more than one map server to connect, this is deprecated dangerous feature USE IT AT YOUR OWN RISK") +# else +# warning your settings allow more than one map server to connect, this is deprecated dangerous feature USE IT AT YOUR OWN RISK +# endif +#endif + // private declarations char char_db[256] = "char"; char scdata_db[256] = "sc_data"; @@ -1882,7 +1890,7 @@ int char_mmo_char_tobuf(uint8* buffer, struct mmo_charstatus* p) { //When the weapon is sent and your option is riding, the client crashes on login!? // FIXME[Haru]: is OPTION_HANBOK intended to be part of this list? And if it is, should the list also include other OPTION_ costumes? - WBUFW(buf,56) = p->option&(OPTION_RIDING|OPTION_DRAGON|OPTION_WUG|OPTION_WUGRIDER|OPTION_MADOGEAR|OPTION_HANBOK) ? 0 : p->weapon; + WBUFW(buf,56) = (p->option&(OPTION_RIDING|OPTION_DRAGON|OPTION_WUG|OPTION_WUGRIDER|OPTION_MADOGEAR|OPTION_HANBOK)) ? 0 : p->weapon; WBUFW(buf,58) = p->base_level; WBUFW(buf,60) = min(p->skill_point, INT16_MAX); @@ -5750,11 +5758,25 @@ static CMDLINEARG(netconfig) chr->NET_CONF_NAME = aStrdup(params); return true; } + +/** + * --run-once handler + * + * Causes the server to run its loop once, and shutdown. Useful for testing. + * @see cmdline->exec + */ +static CMDLINEARG(runonce) +{ + core->runflag = CORE_ST_STOP; + return true; +} + /** * Initializes the command line arguments handlers. */ void cmdline_args_init_local(void) { + CMDLINEARG_DEF2(run-once, runonce, "Closes server after loading (testing).", CMDLINE_OPT_NORMAL); CMDLINEARG_DEF2(char-config, charconfig, "Alternative char-server configuration.", CMDLINE_OPT_PARAM); CMDLINEARG_DEF2(inter-config, interconfig, "Alternative inter-server configuration.", CMDLINE_OPT_PARAM); CMDLINEARG_DEF2(net-config, netconfig, "Alternative network configuration.", CMDLINE_OPT_PARAM); @@ -5793,11 +5815,13 @@ int do_init(int argc, char **argv) { sockt->net_config_read(chr->NET_CONF_NAME); chr->sql_config_read(chr->SQL_CONF_NAME); +#ifndef BUILDBOT if (strcmp(chr->userid, "s1")==0 && strcmp(chr->passwd, "p1")==0) { ShowWarning("Using the default user/password s1/p1 is NOT RECOMMENDED.\n"); ShowNotice("Please edit your 'login' table to create a proper inter-server user/password (gender 'S')\n"); ShowNotice("And then change the user/password to use in conf/char-server.conf (or conf/import/char_conf.txt)\n"); } +#endif inter->init_sql(chr->INTER_CONF_NAME); // inter server configuration diff --git a/src/char/char.h b/src/char/char.h index 9cde18e96..a0cfb3bd7 100644 --- a/src/char/char.h +++ b/src/char/char.h @@ -68,7 +68,11 @@ struct mmo_map_server { VECTOR_DECL(uint16) maps; }; -#define MAX_MAP_SERVERS 2 +/** + * deprecated feature, multi map been a dangerous in-complete feature for so long and going to be removed. + * USE IT AT YOUR OWN RISK! + */ +#define MAX_MAP_SERVERS 1 #define DEFAULT_AUTOSAVE_INTERVAL (300*1000) diff --git a/src/char/geoip.c b/src/char/geoip.c index 433ff0918..002045850 100644 --- a/src/char/geoip.c +++ b/src/char/geoip.c @@ -132,9 +132,8 @@ void geoip_final(bool shutdown) **/ void geoip_init(void) { - int i, fno; + int fno; char db_type = 1; - unsigned char delim[3]; struct stat bufa; FILE *db; @@ -165,6 +164,8 @@ void geoip_init(void) if (fseek(db, -3l, SEEK_END) != 0) { db_type = 0; } else { + int i; + unsigned char delim[3]; for (i = 0; i < GEOIP_STRUCTURE_INFO_MAX_SIZE; i++) { if (fread(delim, sizeof(delim[0]), 3, db) != 3) { db_type = 0; diff --git a/src/char/int_guild.c b/src/char/int_guild.c index 21f38d049..d2507a2f9 100644 --- a/src/char/int_guild.c +++ b/src/char/int_guild.c @@ -146,22 +146,17 @@ int inter_guild_tosql(struct guild *g,int flag) *t_info = '\0'; // Insert a new guild the guild - if (flag&GS_BASIC && g->guild_id == -1) - { + if (flag&GS_BASIC && g->guild_id == -1) { strcat(t_info, " guild_create"); // Create a new guild - if( SQL_ERROR == SQL->Query(inter->sql_handle, "INSERT INTO `%s` " - "(`name`,`master`,`guild_lv`,`max_member`,`average_lv`,`char_id`) " - "VALUES ('%s', '%s', '%d', '%d', '%d', '%d')", - guild_db, esc_name, esc_master, g->guild_lv, g->max_member, g->average_lv, g->member[0].char_id) ) - { + if (SQL_ERROR == SQL->Query(inter->sql_handle, "INSERT INTO `%s` " + "(`name`,`master`,`guild_lv`,`max_member`,`average_lv`,`char_id`) " + "VALUES ('%s', '%s', '%d', '%d', '%d', '%d')", + guild_db, esc_name, esc_master, g->guild_lv, g->max_member, g->average_lv, g->member[0].char_id)) { Sql_ShowDebug(inter->sql_handle); - if (g->guild_id == -1) - return 0; //Failed to create guild! - } - else - { + return 0; //Failed to create guild! + } else { g->guild_id = (int)SQL->LastInsertId(inter->sql_handle); new_guild = 1; } diff --git a/src/char/inter.c b/src/char/inter.c index 9fea2885c..d277abec9 100644 --- a/src/char/inter.c +++ b/src/char/inter.c @@ -968,8 +968,8 @@ int mapif_wis_message(struct WisData *wd) //if (wd->len > 2047-56) wd->len = 2047-56; //Force it to fit to avoid crashes. [Skotlex] if (wd->len < 0) wd->len = 0; - if (wd->len >= sizeof(wd->msg) - 1) - wd->len = sizeof(wd->msg) - 1; + if (wd->len >= (int)sizeof(wd->msg) - 1) + wd->len = (int)sizeof(wd->msg) - 1; WBUFW(buf, 0) = 0x3801; WBUFW(buf, 2) = 56 +wd->len; @@ -1085,7 +1085,6 @@ int mapif_parse_broadcast(int fd) int mapif_parse_WisRequest(int fd) { struct WisData* wd; - static int wisid = 0; char name[NAME_LENGTH]; char esc_name[NAME_LENGTH*2+1];// escaped name char* data; @@ -1125,6 +1124,7 @@ int mapif_parse_WisRequest(int fd) } else { + static int wisid = 0; CREATE(wd, struct WisData, 1); // Whether the failure of previous wisp/page transmission (timeout) @@ -1172,7 +1172,7 @@ int mapif_parse_WisToGM(int fd) { unsigned char buf[2048]; // 0x3003/0x3803 <packet_len>.w <wispname>.24B <min_gm_level>.w <message>.?B - memcpy(WBUFP(buf,0), RFIFOP(fd,0), RFIFOW(fd,2)); + memcpy(WBUFP(buf,0), RFIFOP(fd,0), RFIFOW(fd,2)); // Message contains the NUL terminator (see intif_wis_message_to_gm()) WBUFW(buf, 0) = 0x3803; mapif->sendall(buf, RFIFOW(fd,2)); diff --git a/src/common/HPM.c b/src/common/HPM.c index d3d050d27..8e0bbe992 100644 --- a/src/common/HPM.c +++ b/src/common/HPM.c @@ -38,6 +38,7 @@ #include "common/timer.h" #include "common/utils.h" #include "common/nullpo.h" +#include "plugins/HPMHooking.h" #include <stdio.h> #include <stdlib.h> @@ -51,6 +52,7 @@ struct malloc_interface iMalloc_HPM; struct malloc_interface *HPMiMalloc; struct HPM_interface HPM_s; struct HPM_interface *HPM; +struct HPMHooking_core_interface HPMHooking_core_s; /** * (char*) data name -> (unsigned int) HPMDataCheck[] index @@ -341,13 +343,13 @@ void hplugins_removeFromHPData(enum HPluginDataTypes type, uint32 pluginID, stru /* TODO: add ability for tracking using pID for the upcoming runtime load/unload support. */ bool HPM_AddHook(enum HPluginHookType type, const char *target, void *hook, unsigned int pID) { - if (!HPM->hooking) { + if (!HPM->hooking->enabled) { ShowError("HPM:AddHook Fail! '%s' tried to hook to '%s' but HPMHooking is disabled!\n",HPM->pid2name(pID),target); return false; } /* search if target is a known hook point within 'common' */ /* if not check if a sub-hooking list is available (from the server) and run it by */ - if (HPM->addhook_sub && HPM->addhook_sub(type,target,hook,pID)) + if (HPM->hooking->addhook_sub != NULL && HPM->hooking->addhook_sub(type,target,hook,pID)) return true; ShowError("HPM:AddHook: unknown Hooking Point '%s'!\n",target); @@ -358,12 +360,12 @@ bool HPM_AddHook(enum HPluginHookType type, const char *target, void *hook, unsi void HPM_HookStop(const char *func, unsigned int pID) { /* track? */ - HPM->force_return = true; + HPM->hooking->force_return = true; } -bool HPM_HookStopped (void) +bool HPM_HookStopped(void) { - return HPM->force_return; + return HPM->hooking->force_return; } /** @@ -387,12 +389,12 @@ bool hpm_add_arg(unsigned int pluginID, char *name, bool has_param, CmdlineExecF ARR_FIND(0, VECTOR_LENGTH(cmdline->args_data), i, strcmp(VECTOR_INDEX(cmdline->args_data, i).name, name) == 0); - if (i != VECTOR_LENGTH(cmdline->args_data)) { - ShowError("HPM:add_arg:%s duplicate! (from %s)\n",name,HPM->pid2name(pluginID)); - return false; - } + if (i != VECTOR_LENGTH(cmdline->args_data)) { + ShowError("HPM:add_arg:%s duplicate! (from %s)\n",name,HPM->pid2name(pluginID)); + return false; + } - return cmdline->arg_add(pluginID, name, '\0', func, help, has_param ? CMDLINE_OPT_PARAM : CMDLINE_OPT_NORMAL); + return cmdline->arg_add(pluginID, name, '\0', func, help, has_param ? CMDLINE_OPT_PARAM : CMDLINE_OPT_NORMAL); } /** @@ -567,16 +569,20 @@ struct hplugin *hplugin_load(const char* filename) { plugin->hpi->addToHPData = hplugins_addToHPData; plugin->hpi->getFromHPData = hplugins_getFromHPData; plugin->hpi->removeFromHPData = hplugins_removeFromHPData; - plugin->hpi->AddHook = HPM_AddHook; - plugin->hpi->HookStop = HPM_HookStop; - plugin->hpi->HookStopped = HPM_HookStopped; plugin->hpi->addArg = hpm_add_arg; plugin->hpi->addConf = hplugins_addconf; + if ((plugin->hpi->hooking = plugin_import(plugin->dll, "HPMHooking_s", struct HPMHooking_interface *)) != NULL) { + plugin->hpi->hooking->AddHook = HPM_AddHook; + plugin->hpi->hooking->HookStop = HPM_HookStop; + plugin->hpi->hooking->HookStopped = HPM_HookStopped; + } /* server specific */ if( HPM->load_sub ) HPM->load_sub(plugin); - ShowStatus("HPM: Loaded plugin '"CL_WHITE"%s"CL_RESET"' (%s).\n", plugin->info->name, plugin->info->version); + ShowStatus("HPM: Loaded plugin '"CL_WHITE"%s"CL_RESET"' (%s)%s.\n", + plugin->info->name, plugin->info->version, + plugin->hpi->hooking != NULL ? " built with HPMHooking support" : ""); return plugin; } @@ -660,12 +666,13 @@ void hplugins_config_read(void) { bool (*addhook_sub) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID); if ((func = plugin_import(plugin->dll, "Hooked",const char * (*)(bool *))) != NULL && (addhook_sub = plugin_import(plugin->dll, "HPM_Plugin_AddHook",bool (*)(enum HPluginHookType, const char *, void *, unsigned int))) != NULL) { - const char *failed = func(&HPM->force_return); + const char *failed = func(&HPM->hooking->force_return); if (failed) { ShowError("HPM: failed to retrieve '%s' for '"CL_WHITE"%s"CL_RESET"'!\n", failed, plugin_name); } else { - HPM->hooking = true; - HPM->addhook_sub = addhook_sub; + HPM->hooking->enabled = true; + HPM->hooking->addhook_sub = addhook_sub; + HPM->hooking->Hooked = func; // The purpose of this is type-checking 'func' at compile time. } } } @@ -1046,11 +1053,10 @@ void hpm_final(void) void hpm_defaults(void) { HPM = &HPM_s; + HPM->hooking = &HPMHooking_core_s; memset(&HPM->filenames, 0, sizeof(HPM->filenames)); VECTOR_INIT(HPM->cmdline_load_plugins); - HPM->force_return = false; - HPM->hooking = false; /* */ HPM->init = hpm_init; HPM->final = hpm_final; @@ -1067,7 +1073,6 @@ void hpm_defaults(void) HPM->pid2name = hplugins_id2name; HPM->parse_packets = hplugins_parse_packets; HPM->load_sub = NULL; - HPM->addhook_sub = NULL; HPM->parseConf = hplugins_parse_conf; HPM->getBattleConf = hplugins_get_battle_conf; HPM->DataCheck = HPM_DataCheck; @@ -1078,4 +1083,9 @@ void hpm_defaults(void) HPM->data_store_create = hplugin_data_store_create; HPM->data_store_validate = hplugin_data_store_validate; HPM->data_store_validate_sub = NULL; + + HPM->hooking->enabled = false; + HPM->hooking->force_return = false; + HPM->hooking->addhook_sub = NULL; + HPM->hooking->Hooked = NULL; } diff --git a/src/common/HPM.h b/src/common/HPM.h index 109549aad..0b1275fde 100644 --- a/src/common/HPM.h +++ b/src/common/HPM.h @@ -65,6 +65,8 @@ #endif // WIN32 +struct HPMHooking_core_interface; + struct hplugin { DLL dll; unsigned int idx; @@ -126,9 +128,6 @@ struct HPM_interface { /* vars */ unsigned int version[2]; bool off; - bool hooking; - /* hooking */ - bool force_return; /* data */ VECTOR_DECL(struct hplugin *) plugins; VECTOR_DECL(struct hpm_symbol *) symbols; @@ -159,7 +158,6 @@ struct HPM_interface { char *(*pid2name) (unsigned int pid); unsigned char (*parse_packets) (int fd, int packet_id, enum HPluginPacketHookingPoints point); void (*load_sub) (struct hplugin *plugin); - bool (*addhook_sub) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID); /* for custom config parsing */ bool (*parseConf) (const char *w1, const char *w2, enum HPluginConfType point); bool (*getBattleConf) (const char* w1, int *value); @@ -173,6 +171,9 @@ struct HPM_interface { bool (*data_store_validate) (enum HPluginDataTypes type, struct hplugin_data_store **storeptr, bool initialize); /* for server-specific HPData e.g. map_session_data */ bool (*data_store_validate_sub) (enum HPluginDataTypes type, struct hplugin_data_store **storeptr, bool initialize); + + /* hooking */ + struct HPMHooking_core_interface *hooking; }; CMDLINEARG(loadplugin); diff --git a/src/common/HPMDataCheck.h b/src/common/HPMDataCheck.h index e5f482686..332857a90 100644 --- a/src/common/HPMDataCheck.h +++ b/src/common/HPMDataCheck.h @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + #ifndef HPM_DATA_CHECK_H #define HPM_DATA_CHECK_H @@ -414,6 +416,7 @@ HPExport const struct s_HPMDataCheck HPMDataCheck[] = { #ifdef MAP_IRC_BOT_H { "irc_bot_interface", sizeof(struct irc_bot_interface), SERVER_TYPE_MAP }, { "irc_func", sizeof(struct irc_func), SERVER_TYPE_MAP }, + { "message_flood", sizeof(struct message_flood), SERVER_TYPE_MAP }, #else #define MAP_IRC_BOT_H #endif // MAP_IRC_BOT_H @@ -532,6 +535,7 @@ HPExport const struct s_HPMDataCheck HPMDataCheck[] = { { "packet_bgqueue_revoke_req", sizeof(struct packet_bgqueue_revoke_req), SERVER_TYPE_MAP }, { "packet_bgqueue_update_info", sizeof(struct packet_bgqueue_update_info), SERVER_TYPE_MAP }, { "packet_cart_additem_ack", sizeof(struct packet_cart_additem_ack), SERVER_TYPE_MAP }, + { "packet_chat_message", sizeof(struct packet_chat_message), SERVER_TYPE_MAP }, { "packet_damage", sizeof(struct packet_damage), SERVER_TYPE_MAP }, { "packet_dropflooritem", sizeof(struct packet_dropflooritem), SERVER_TYPE_MAP }, { "packet_equip_item", sizeof(struct packet_equip_item), SERVER_TYPE_MAP }, @@ -574,6 +578,7 @@ HPExport const struct s_HPMDataCheck HPMDataCheck[] = { { "packet_unequipitem_ack", sizeof(struct packet_unequipitem_ack), SERVER_TYPE_MAP }, { "packet_unit_walking", sizeof(struct packet_unit_walking), SERVER_TYPE_MAP }, { "packet_viewequip_ack", sizeof(struct packet_viewequip_ack), SERVER_TYPE_MAP }, + { "packet_whisper_message", sizeof(struct packet_whisper_message), SERVER_TYPE_MAP }, { "packet_wis_end", sizeof(struct packet_wis_end), SERVER_TYPE_MAP }, #else #define MAP_PACKETS_STRUCT_H @@ -645,6 +650,7 @@ HPExport const struct s_HPMDataCheck HPMDataCheck[] = { { "casecheck_data", sizeof(struct casecheck_data), SERVER_TYPE_MAP }, { "reg_db", sizeof(struct reg_db), SERVER_TYPE_MAP }, { "script_array", sizeof(struct script_array), SERVER_TYPE_MAP }, + { "script_buf", sizeof(struct script_buf), SERVER_TYPE_MAP }, { "script_code", sizeof(struct script_code), SERVER_TYPE_MAP }, { "script_data", sizeof(struct script_data), SERVER_TYPE_MAP }, { "script_function", sizeof(struct script_function), SERVER_TYPE_MAP }, @@ -659,6 +665,7 @@ HPExport const struct s_HPMDataCheck HPMDataCheck[] = { { "script_syntax_data", sizeof(struct script_syntax_data), SERVER_TYPE_MAP }, { "str_data_struct", sizeof(struct str_data_struct), SERVER_TYPE_MAP }, { "string_translation", sizeof(struct string_translation), SERVER_TYPE_MAP }, + { "string_translation_entry", sizeof(struct string_translation_entry), SERVER_TYPE_MAP }, #else #define MAP_SCRIPT_H #endif // MAP_SCRIPT_H diff --git a/src/common/HPMSymbols.inc.h b/src/common/HPMSymbols.inc.h index be758a055..516222e8e 100644 --- a/src/common/HPMSymbols.inc.h +++ b/src/common/HPMSymbols.inc.h @@ -2,7 +2,7 @@ * This file is part of Hercules. * http://herc.ws - http://github.com/HerculesWS/Hercules * - * Copyright (C) 2015-2016 Hercules Dev Team + * Copyright (C) 2013-2016 Hercules Dev Team * * Hercules is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + #if !defined(HERCULES_CORE) #ifdef COMMON_UTILS_H /* HCache */ struct HCache_interface *HCache; diff --git a/src/common/HPMi.h b/src/common/HPMi.h index 72640b382..e16eb1d75 100644 --- a/src/common/HPMi.h +++ b/src/common/HPMi.h @@ -25,6 +25,7 @@ #include "common/core.h" #include "common/showmsg.h" +struct HPMHooking_interface; struct Sql; // common/sql.h struct script_state; struct AtCommandInfo; @@ -32,7 +33,7 @@ struct socket_data; struct map_session_data; struct hplugin_data_store; -#define HPM_VERSION "1.1" +#define HPM_VERSION "1.2" #define HPM_ADDCONF_LENGTH 40 struct hplugin_info { @@ -71,11 +72,6 @@ enum HPluginPacketHookingPoints { hpPHP_MAX, }; -enum HPluginHookType { - HOOK_TYPE_PRE, - HOOK_TYPE_POST, -}; - /** * Data types for plugin custom data. */ @@ -107,13 +103,6 @@ enum HPluginConfType { HPCT_MAX, }; -#define addHookPre(tname,hook) (HPMi->AddHook(HOOK_TYPE_PRE,(tname),(hook),HPMi->pid)) -#define addHookPost(tname,hook) (HPMi->AddHook(HOOK_TYPE_POST,(tname),(hook),HPMi->pid)) -/* need better names ;/ */ -/* will not run the original function after pre-hook processing is complete (other hooks will run) */ -#define hookStop() (HPMi->HookStop(__func__,HPMi->pid)) -#define hookStopped() (HPMi->HookStopped()) - #define addArg(name, param,func,help) (HPMi->addArg(HPMi->pid,(name),(param),(cmdline_arg_ ## func),(help))) /* HPData handy redirects */ /* session[] */ @@ -231,10 +220,6 @@ struct HPMi_interface { void (*removeFromHPData) (enum HPluginDataTypes type, uint32 pluginID, struct hplugin_data_store *store, uint32 classid); /* packet */ bool (*addPacket) (unsigned short cmd, unsigned short length, void (*receive)(int fd), unsigned int point, unsigned int pluginID); - /* Hooking */ - bool (*AddHook) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID); - void (*HookStop) (const char *func, unsigned int pID); - bool (*HookStopped) (void); /* program --arg/-a */ bool (*addArg) (unsigned int pluginID, char *name, bool has_param, CmdlineExecFunc func, const char *help); /* battle-config recv param */ @@ -243,6 +228,9 @@ struct HPMi_interface { void (*addPCGPermission) (unsigned int pluginID, char *name, unsigned int *mask); struct Sql *sql_handle; + + /* Hooking */ + struct HPMHooking_interface *hooking; }; #ifdef HERCULES_CORE #define HPM_SYMBOL(n, s) (HPM->share((s), (n)), true) diff --git a/src/common/Makefile.in b/src/common/Makefile.in index 4580f70b8..6e7ffa088 100644 --- a/src/common/Makefile.in +++ b/src/common/Makefile.in @@ -50,7 +50,8 @@ COMMON_C += console.c core.c memmgr.c socket.c COMMON_H = atomic.h cbasetypes.h conf.h console.h core.h db.h des.h ers.h \ grfio.h hercules.h HPM.h HPMi.h memmgr.h mapindex.h md5calc.h \ mmo.h mutex.h nullpo.h random.h showmsg.h socket.h spinlock.h \ - sql.h strlib.h sysinfo.h thread.h timer.h utils.h winapi.h + sql.h strlib.h sysinfo.h thread.h timer.h utils.h winapi.h \ + ../plugins/HPMHooking.h COMMON_PH = COMMON_SQL_OBJ = obj_sql/sql.o diff --git a/src/common/cbasetypes.h b/src/common/cbasetypes.h index 3675d8fa4..d3db86543 100644 --- a/src/common/cbasetypes.h +++ b/src/common/cbasetypes.h @@ -118,16 +118,6 @@ #include <limits.h> #include <time.h> -// temporary fix for bugreport:4961 (unintended conversion from signed to unsigned) -// (-20 >= UCHAR_MAX) returns true -// (-20 >= USHRT_MAX) returns true -#if defined(__FreeBSD__) && defined(__x86_64) -#undef UCHAR_MAX -#define UCHAR_MAX ((unsigned char)0xff) -#undef USHRT_MAX -#define USHRT_MAX ((unsigned short)0xffff) -#endif - // ILP64 isn't supported, so always 32 bits? #ifndef UINT_MAX #define UINT_MAX 0xffffffff @@ -262,16 +252,13 @@ typedef uintptr_t uintptr; #if defined(__BORLANDC__) || _MSC_VER < 1900 #define snprintf _snprintf #endif -#if defined(_MSC_VER) && _MSC_VER < 1400 -#define vsnprintf _vsnprintf -#endif #else #define strcmpi strcasecmp #define stricmp strcasecmp #define strncmpi strncasecmp #define strnicmp strncasecmp #endif -#if defined(_MSC_VER) && _MSC_VER > 1200 +#if defined(_MSC_VER) #define strtoull _strtoui64 #define strtoll _strtoi64 #endif @@ -342,24 +329,6 @@ typedef char bool; //#define swap(a,b) if (a != b) ((a ^= b), (b ^= a), (a ^= b)) // but is vulnerable to 'if (foo) swap(bar, baz); else quux();', causing the else to nest incorrectly. #define swap(a,b) do { if ((a) != (b)) { (a) ^= (b); (b) ^= (a); (a) ^= (b); } } while(0) -#if 0 //to be activated soon, more tests needed on how VS works with the macro above -#ifdef WIN32 -#undef swap -#define swap(a,b)__asm { \ - __asm mov eax, dword ptr [a] \ - __asm cmp eax, dword ptr [b] \ - __asm je _ret \ - __asm xor eax, dword ptr [b] \ - __asm mov dword ptr [a], eax \ - __asm xor eax, dword ptr [b] \ - __asm mov dword ptr [b], eax \ - __asm xor eax, dword ptr [a] \ - __asm mov dword ptr [a], eax \ - __asm _ret: \ -} -#endif -#endif - #define swap_ptr(a,b) do { if ((a) != (b)) (a) = (void*)((intptr_t)(a) ^ (intptr_t)(b)); (b) = (void*)((intptr_t)(a) ^ (intptr_t)(b)); (a) = (void*)((intptr_t)(a) ^ (intptr_t)(b)); } while(0) #ifndef max diff --git a/src/common/core.c b/src/common/core.c index ccd80c44b..e6b522926 100644 --- a/src/common/core.c +++ b/src/common/core.c @@ -33,6 +33,7 @@ #include "common/strlib.h" #include "common/sysinfo.h" #include "common/nullpo.h" +#include "common/utils.h" #ifndef MINICORE # include "common/HPM.h" @@ -42,7 +43,6 @@ # include "common/sql.h" # include "common/thread.h" # include "common/timer.h" -# include "common/utils.h" #endif #ifndef _WIN32 @@ -54,6 +54,28 @@ #include <stdio.h> #include <stdlib.h> +/* + * Uncomment the line below if you want to silence the root warning on startup + * (not recommended, as it opens the machine to security risks. You should + * never ever run software as root unless it requires the extra privileges + * (which Hercules does not.) + * More info: + * http://www.tldp.org/HOWTO/Security-HOWTO/local-security.html + * http://www.gentoo.org/doc/en/security/security-handbook.xml?style=printable&part=1&chap=1#doc_chap4 + * http://wiki.centos.org/TipsAndTricks/BecomingRoot + * http://fedoraproject.org/wiki/Configuring_Sudo + * https://help.ubuntu.com/community/RootSudo + * http://www.freebsdwiki.net/index.php/Root + * + * If your service provider forces (or encourages) you to run server software + * as root, please complain to them before and after uncommenting this line, + * since it is a very bad idea. + * Please note that NO SUPPORT will be given if you uncomment the following line. + */ +//#define I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT +// And don't complain to us if the XYZ plugin you installed wiped your hard disk, or worse. +// Note: This feature is deprecated, and should not be used. + /// Called when a terminate signal is received. void (*shutdown_callback)(void) = NULL; @@ -172,11 +194,51 @@ void signals_init (void) { /** * Warns the user if executed as superuser (root) + * + * @retval false if the check didn't pass and the program should be terminated. */ -void usercheck(void) { +bool usercheck(void) +{ +#ifndef _WIN32 if (sysinfo->is_superuser()) { - ShowWarning("You are running Hercules with root privileges, it is not necessary.\n"); + if (!isatty(fileno(stdin))) { +#ifdef BUILDBOT + return true; +#else // BUILDBOT + ShowFatalError("You are running Hercules with root privileges, it is not necessary, nor recommended. " + "Aborting.\n"); + return false; // Don't allow noninteractive execution regardless. +#endif // BUILDBOT + } + ShowError("You are running Hercules with root privileges, it is not necessary, nor recommended.\n"); +#ifdef I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT +#ifndef BUILDBOT +#warning This Hercules build is not eligible to obtain support by the developers. +#warning The setting I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT is deprecated and should not be used. +#endif // BUILDBOT +#else // not I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT + ShowNotice("Execution will be paused for 60 seconds. Press Ctrl-C if you wish to quit.\n"); + ShowNotice("If you want to get rid of this message, please open %s and uncomment, near the top, the line saying:\n" + "\t\"//#define I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT\"\n", __FILE__); + ShowNotice("Note: In a near future, this courtesy notice will go away. " + "Please update your infrastructure not to require root privileges before then.\n"); + ShowWarning("It's recommended that you " CL_WHITE "press CTRL-C now!" CL_RESET "\n"); + { + int i; + for (i = 0; i < 60; i++) { + ShowMessage("\a *"); + HSleep(1); + } + } + ShowMessage("\n"); + ShowNotice("Resuming operations with root privileges. " + CL_RED "If anything breaks, you get to keep the pieces, " + "and the Hercules developers won't be able to help you." + CL_RESET "\n"); +#endif // I_AM_AWARE_OF_THE_RISK_AND_STILL_WANT_TO_RUN_HERCULES_AS_ROOT } +#endif // not _WIN32 + return true; } void core_defaults(void) { @@ -426,7 +488,8 @@ int main (int argc, char **argv) { if (!(showmsg->silent&0x1)) console->display_title(); - usercheck(); + if (!usercheck()) + return EXIT_FAILURE; #ifdef MINICORE // minimalist Core do_init(argc,argv); diff --git a/src/common/db.h b/src/common/db.h index d7d111c86..1c0955221 100644 --- a/src/common/db.h +++ b/src/common/db.h @@ -1395,6 +1395,16 @@ HPShared struct db_interface *DB; } while(false) /** + * Removes all values from the vector. + * + * Does not free the allocated data. + */ +#define VECTOR_TRUNCATE(_vec) \ + do { \ + VECTOR_LENGTH(_vec) = 0; \ + } while (false) + +/** * Clears the vector, freeing allocated data. * * @param _vec Vector. diff --git a/src/common/grfio.c b/src/common/grfio.c index 678875c91..c6e47d357 100644 --- a/src/common/grfio.c +++ b/src/common/grfio.c @@ -410,12 +410,12 @@ void *grfio_reads(const char *fname, int *size) // LocalFileCheck char lfname[256]; FILE *in; - unsigned char *buf = NULL; grfio_localpath_create(lfname, sizeof(lfname), (entry && entry->fnd) ? entry->fnd : fname); in = fopen(lfname, "rb"); if (in != NULL) { int declen; + unsigned char *buf = NULL; fseek(in,0,SEEK_END); declen = (int)ftell(in); if (declen == -1) { diff --git a/src/common/memmgr.c b/src/common/memmgr.c index 15e55fbeb..dfea24465 100644 --- a/src/common/memmgr.c +++ b/src/common/memmgr.c @@ -154,8 +154,8 @@ void* aReallocz_(void *p, size_t size, const char *file, int line, const char *f #ifdef USE_MEMMGR ret = REALLOC(p, size, file, line, func); #else - size_t newSize; - if (p) { + if (p != NULL) { + size_t newSize; size_t oldSize = BUFFER_SIZE(p); ret = REALLOC(p, size, file, line, func); newSize = BUFFER_SIZE(ret); @@ -167,7 +167,7 @@ void* aReallocz_(void *p, size_t size, const char *file, int line, const char *f memset(ret, 0, BUFFER_SIZE(ret)); } #endif - if (ret == NULL){ + if (ret == NULL) { ShowFatalError("%s:%d: in func %s: aRealloc error out of memory!\n",file,line,func); exit(EXIT_FAILURE); } diff --git a/src/common/mmo.h b/src/common/mmo.h index a2080d900..3d3360132 100644 --- a/src/common/mmo.h +++ b/src/common/mmo.h @@ -125,29 +125,69 @@ //Official Limit: 2.1b ( the var that stores the money doesn't go much higher than this by default ) #define MAX_BANK_ZENY INT_MAX +#ifndef MAX_LEVEL #define MAX_LEVEL 175 +#endif #define MAX_FAME 1000000000 #define MAX_CART 100 +#ifndef MAX_SKILL #define MAX_SKILL 1478 +#endif +#ifndef MAX_SKILL_ID #define MAX_SKILL_ID 10015 // [Ind/Hercules] max used skill ID +#endif +#ifndef MAX_SKILL_TREE // Update this max as necessary. 86 is the value needed for Expanded Super Novice. #define MAX_SKILL_TREE 86 +#endif +#ifndef DEFAULT_WALK_SPEED #define DEFAULT_WALK_SPEED 150 +#endif +#ifndef MIN_WALK_SPEED #define MIN_WALK_SPEED 20 /* below 20 clips animation */ +#endif +#ifndef MAX_WALK_SPEED #define MAX_WALK_SPEED 1000 +#endif +#ifndef MAX_STORAGE #define MAX_STORAGE 600 +#endif +#ifndef MAX_GUILD_STORAGE #define MAX_GUILD_STORAGE 600 +#endif +#ifndef MAX_PARTY #define MAX_PARTY 12 +#endif +#ifndef BASE_GUILD_SIZE #define BASE_GUILD_SIZE 16 // Base guild members (without GD_EXTENSION) +#endif +#ifndef MAX_GUILD #define MAX_GUILD (BASE_GUILD_SIZE+10*6) // Increased max guild members +6 per 1 extension levels [Lupus] +#endif +#ifndef MAX_GUILDPOSITION #define MAX_GUILDPOSITION 20 // Increased max guild positions to accomodate for all members [Valaris] (removed) [PoW] +#endif +#ifndef MAX_GUILDEXPULSION #define MAX_GUILDEXPULSION 32 +#endif +#ifndef MAX_GUILDALLIANCE #define MAX_GUILDALLIANCE 16 +#endif +#ifndef MAX_GUILDSKILL #define MAX_GUILDSKILL 15 // Increased max guild skills because of new skills [Sara-chan] +#endif +#ifndef MAX_GUILDLEVEL #define MAX_GUILDLEVEL 50 +#endif +#ifndef MAX_GUARDIANS #define MAX_GUARDIANS 8 // Local max per castle. [Skotlex] +#endif +#ifndef MAX_QUEST_OBJECTIVES #define MAX_QUEST_OBJECTIVES 3 // Max quest objectives for a quest +#endif +#ifndef MAX_START_ITEMS #define MAX_START_ITEMS 32 // Max number of items allowed to be given to a char whenever it's created. [mkbu95] +#endif // for produce #define MIN_ATTRIBUTE 0 @@ -170,7 +210,9 @@ #define MAP_NAME_LENGTH (11 + 1) #define MAP_NAME_LENGTH_EXT (MAP_NAME_LENGTH + 4) +#ifndef MAX_FRIENDS #define MAX_FRIENDS 40 +#endif #define MAX_MEMOPOINTS 3 // Size of the fame list arrays. @@ -186,8 +228,12 @@ #define MAX_GUILDMES2 120 // Base Homun skill. +#ifndef HM_SKILLBASE #define HM_SKILLBASE 8001 +#endif +#ifndef MAX_HOMUNSKILL #define MAX_HOMUNSKILL 43 +#endif // Mail System #define MAIL_MAX_INBOX 30 @@ -195,13 +241,23 @@ #define MAIL_BODY_LENGTH 200 // Mercenary System +#ifndef MC_SKILLBASE #define MC_SKILLBASE 8201 +#endif +#ifndef MAX_MERCSKILL #define MAX_MERCSKILL 40 +#endif // Elemental System +#ifndef MAX_ELEMENTALSKILL #define MAX_ELEMENTALSKILL 42 +#endif +#ifndef EL_SKILLBASE #define EL_SKILLBASE 8401 +#endif +#ifndef MAX_ELESKILLTREE #define MAX_ELESKILLTREE 3 +#endif // The following system marks a different job ID system used by the map server, // which makes a lot more sense than the normal one. [Skotlex] @@ -233,7 +289,9 @@ enum item_types { IT_AMMO, //10 IT_DELAYCONSUME,//11 IT_CASH = 18, +#ifndef IT_MAX IT_MAX +#endif }; #define INDEX_NOT_FOUND (-1) ///< Used as invalid/failure value in various functions that return an index @@ -253,6 +311,11 @@ struct quest { enum quest_state state; ///< Current quest state }; +enum attribute_flag { + ATTR_NONE = 0, + ATTR_BROKEN = 1, +}; + struct item { int id; short nameid; @@ -325,7 +388,9 @@ enum e_item_bound_type { IBT_GUILD = 0x2, IBT_PARTY = 0x3, IBT_CHARACTER = 0x4, +#ifndef IBT_MAX IBT_MAX = 0x4, +#endif }; enum { @@ -772,7 +837,9 @@ enum { GD_RESTORE=10012, GD_EMERGENCYCALL=10013, GD_DEVELOPMENT=10014, +#ifndef GD_MAX GD_MAX, +#endif }; //These mark the ID of the jobs, as expected by the client. [Skotlex] @@ -929,7 +996,9 @@ enum { JOB_OBORO, JOB_REBELLION = 4215, +#ifndef JOB_MAX JOB_MAX, +#endif }; //Total number of classes (for data storage) @@ -966,7 +1035,9 @@ enum weapon_type { W_GRENADE, //21 W_HUUMA, //22 W_2HSTAFF, //23 +#ifndef MAX_SINGLE_WEAPON_TYPE MAX_SINGLE_WEAPON_TYPE, +#endif // dual-wield constants W_DOUBLE_DD, ///< 2 daggers W_DOUBLE_SS, ///< 2 swords @@ -974,7 +1045,9 @@ enum weapon_type { W_DOUBLE_DS, ///< dagger + sword W_DOUBLE_DA, ///< dagger + axe W_DOUBLE_SA, ///< sword + axe +#ifndef MAX_WEAPON_TYPE MAX_WEAPON_TYPE, +#endif }; enum ammo_type { diff --git a/src/common/showmsg.c b/src/common/showmsg.c index 1c1d4ca8b..8ed8efc1d 100644 --- a/src/common/showmsg.c +++ b/src/common/showmsg.c @@ -244,13 +244,13 @@ int VFPRINTF(HANDLE handle, const char *fmt, va_list argptr) continue; } else if (*q == ';') { // delimiter - if (numpoint < sizeof(numbers)/sizeof(*numbers)) { + if (numpoint < ARRAYLENGTH(numbers)) { // go to next array position numpoint++; } else { // array is full, so we 'forget' the first value - memmove(numbers,numbers+1,sizeof(numbers)/sizeof(*numbers)-1); - numbers[sizeof(numbers)/sizeof(*numbers)-1]=0; + memmove(numbers, numbers+1, ARRAYLENGTH(numbers)-1); + numbers[ARRAYLENGTH(numbers)-1]=0; } ++q; // and next number @@ -605,9 +605,6 @@ int vShowMessage_(enum msg_type flag, const char *string, va_list ap) { va_list apcopy; char prefix[100]; -#if defined(DEBUGLOGMAP) || defined(DEBUGLOGCHAR) || defined(DEBUGLOGLOGIN) - FILE *fp; -#endif if (!string || *string == '\0') { ShowError("Empty string passed to vShowMessage_().\n"); @@ -702,8 +699,8 @@ int vShowMessage_(enum msg_type flag, const char *string, va_list ap) } #if defined(DEBUGLOGMAP) || defined(DEBUGLOGCHAR) || defined(DEBUGLOGLOGIN) - if(strlen(DEBUGLOGPATH) > 0) { - fp=fopen(DEBUGLOGPATH,"a"); + if (strlen(DEBUGLOGPATH) > 0) { + FILE *fp = fopen(DEBUGLOGPATH,"a"); if (fp == NULL) { FPRINTF(STDERR, CL_RED"[ERROR]"CL_RESET": Could not open '"CL_WHITE"%s"CL_RESET"', access denied.\n", DEBUGLOGPATH); FFLUSH(STDERR); diff --git a/src/common/showmsg.h b/src/common/showmsg.h index 7b48d0df2..303c8dd28 100644 --- a/src/common/showmsg.h +++ b/src/common/showmsg.h @@ -130,7 +130,11 @@ struct showmsg_interface { #define ShowSQL(fmt, ...) (showmsg->showSQL((fmt), ##__VA_ARGS__)) #define ShowInfo(fmt, ...) (showmsg->showInfo((fmt), ##__VA_ARGS__)) #define ShowNotice(fmt, ...) (showmsg->showNotice((fmt), ##__VA_ARGS__)) +#ifdef BUILDBOT +#define ShowWarning(fmt, ...) (showmsg->showError((fmt), ##__VA_ARGS__)) +#else // BUILDBOT #define ShowWarning(fmt, ...) (showmsg->showWarning((fmt), ##__VA_ARGS__)) +#endif // BUILDBOT #define ShowDebug(fmt, ...) (showmsg->showDebug((fmt), ##__VA_ARGS__)) #define ShowError(fmt, ...) (showmsg->showError((fmt), ##__VA_ARGS__)) #define ShowFatalError(fmt, ...) (showmsg->showFatalError((fmt), ##__VA_ARGS__)) diff --git a/src/common/socket.c b/src/common/socket.c index 5d4ea06a0..af5e8aa73 100644 --- a/src/common/socket.c +++ b/src/common/socket.c @@ -38,35 +38,39 @@ #include <stdlib.h> #include <sys/types.h> +#ifdef SOCKET_EPOLL +#include <sys/epoll.h> +#endif // SOCKET_EPOLL + #ifdef WIN32 # include "common/winapi.h" -#else +#else // WIN32 # include <arpa/inet.h> # include <errno.h> # include <net/if.h> # include <netdb.h> #if defined __linux__ || defined __linux # include <linux/tcp.h> -#else +#else // defined __linux__ || defined __linux # include <netinet/in.h> # include <netinet/tcp.h> -#endif +#endif // defined __linux__ || defined __linux # include <sys/ioctl.h> # include <sys/socket.h> # include <sys/time.h> # include <unistd.h> -# ifndef SIOCGIFCONF -# include <sys/sockio.h> // SIOCGIFCONF on Solaris, maybe others? [Shinomori] -# endif -# ifndef FIONBIO -# include <sys/filio.h> // FIONBIO on Solaris [FlavioJS] -# endif +#ifndef SIOCGIFCONF +# include <sys/sockio.h> // SIOCGIFCONF on Solaris, maybe others? [Shinomori] +#endif // SIOCGIFCONF +#ifndef FIONBIO +# include <sys/filio.h> // FIONBIO on Solaris [FlavioJS] +#endif // FIONBIO -# ifdef HAVE_SETRLIMIT -# include <sys/resource.h> -# endif -#endif +#ifdef HAVE_SETRLIMIT +# include <sys/resource.h> +#endif // HAVE_SETRLIMIT +#endif // WIN32 /** * Socket Interface Source @@ -82,7 +86,7 @@ struct socket_data **session; void send_shortlist_add_fd(int fd); // Do pending network sends (and eof handling) from the shortlist. void send_shortlist_do_sends(void); -#endif +#endif // SEND_SHORTLIST ///////////////////////////////////////////////////////////////////// #if defined(WIN32) @@ -212,7 +216,7 @@ char* sErr(int code) #define sFD_ZERO FD_ZERO ///////////////////////////////////////////////////////////////////// -#else +#else // defined(WIN32) ///////////////////////////////////////////////////////////////////// // nix portability layer @@ -244,29 +248,40 @@ char* sErr(int code) #define sFD_ZERO FD_ZERO ///////////////////////////////////////////////////////////////////// -#endif +#endif // defined(WIN32) ///////////////////////////////////////////////////////////////////// #ifndef MSG_NOSIGNAL #define MSG_NOSIGNAL 0 -#endif +#endif // MSG_NOSIGNAL +#ifndef SOCKET_EPOLL +// Select based Event Dispatcher: fd_set readfds; +#else // SOCKET_EPOLL +// Epoll based Event Dispatcher: +static int epoll_maxevents = (FD_SETSIZE / 2); +static int epfd = SOCKET_ERROR; +static struct epoll_event epevent; +static struct epoll_event *epevents = NULL; + +#endif // SOCKET_EPOLL + // Maximum packet size in bytes, which the client is able to handle. // Larger packets cause a buffer overflow and stack corruption. #if PACKETVER >= 20131223 static size_t socket_max_client_packet = 0xFFFF; -#else +#else // PACKETVER >= 20131223 static size_t socket_max_client_packet = 0x6000; -#endif +#endif // PACKETVER >= 20131223 #ifdef SHOW_SERVER_STATS // Data I/O statistics static size_t socket_data_i = 0, socket_data_ci = 0, socket_data_qi = 0; static size_t socket_data_o = 0, socket_data_co = 0, socket_data_qo = 0; static time_t socket_data_last_tick = 0; -#endif +#endif // SHOW_SERVER_STATS // initial recv buffer size (this will also be the max. size) // biggest known packet: S 0153 <len>.w <emblem data>.?B -> 24x24 256 color .bmp (0153 + len.w + 1618/1654/1756 bytes) @@ -282,14 +297,14 @@ static time_t socket_data_last_tick = 0; int send_shortlist_array[FD_SETSIZE];// we only support FD_SETSIZE sockets, limit the array to that int send_shortlist_count = 0;// how many fd's are in the shortlist uint32 send_shortlist_set[(FD_SETSIZE+31)/32];// to know if specific fd's are already in the shortlist -#endif +#endif // SEND_SHORTLIST static int create_session(int fd, RecvFunc func_recv, SendFunc func_send, ParseFunc func_parse); #ifndef MINICORE int ip_rules = 1; static int connect_check(uint32 ip); -#endif +#endif // MINICORE const char* error_msg(void) { @@ -380,13 +395,13 @@ void setsocketopts(int fd, struct hSockOpt *opt) ShowWarning("setsocketopts: Unable to set SO_LINGER mode for connection #%d!\n", fd); #ifdef TCP_THIN_LINEAR_TIMEOUTS - if (sSetsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, (char *)&yes, sizeof(yes))) - ShowWarning("setsocketopts: Unable to set TCP_THIN_LINEAR_TIMEOUTS mode for connection #%d!\n", fd); -#endif + if (sSetsockopt(fd, IPPROTO_TCP, TCP_THIN_LINEAR_TIMEOUTS, (char *)&yes, sizeof(yes))) + ShowWarning("setsocketopts: Unable to set TCP_THIN_LINEAR_TIMEOUTS mode for connection #%d!\n", fd); +#endif // TCP_THIN_LINEAR_TIMEOUTS #ifdef TCP_THIN_DUPACK - if (sSetsockopt(fd, IPPROTO_TCP, TCP_THIN_DUPACK, (char *)&yes, sizeof(yes))) - ShowWarning("setsocketopts: Unable to set TCP_THIN_DUPACK mode for connection #%d!\n", fd); -#endif + if (sSetsockopt(fd, IPPROTO_TCP, TCP_THIN_DUPACK, (char *)&yes, sizeof(yes))) + ShowWarning("setsocketopts: Unable to set TCP_THIN_DUPACK mode for connection #%d!\n", fd); +#endif // TCP_THIN_DUPACK } /*====================================== @@ -398,7 +413,7 @@ void set_eof(int fd) #ifdef SEND_SHORTLIST // Add this socket to the shortlist for eof handling. send_shortlist_add_fd(fd); -#endif +#endif // SEND_SHORTLIST sockt->session[fd]->flag.eof = 1; } } @@ -436,7 +451,7 @@ int recv_to_fifo(int fd) { socket_data_ci += len; } -#endif +#endif // SHOW_SERVER_STATS return 0; } @@ -453,12 +468,12 @@ int send_from_fifo(int fd) len = sSend(fd, (const char *) sockt->session[fd]->wdata, (int)sockt->session[fd]->wdata_size, MSG_NOSIGNAL); if( len == SOCKET_ERROR ) - {//An exception has occurred + { //An exception has occurred if( sErrno != S_EWOULDBLOCK ) { //ShowDebug("send_from_fifo: %s, ending connection #%d\n", error_msg(), fd); #ifdef SHOW_SERVER_STATS socket_data_qo -= sockt->session[fd]->wdata_size; -#endif +#endif // SHOW_SERVER_STATS sockt->session[fd]->wdata_size = 0; //Clear the send queue as we can't send anymore. [Skotlex] sockt->eof(fd); } @@ -480,7 +495,7 @@ int send_from_fifo(int fd) { socket_data_co += len; } -#endif +#endif // SHOW_SERVER_STATS } return 0; @@ -534,11 +549,27 @@ int connect_client(int listen_fd) { sockt->close(fd); return -1; } -#endif +#endif // MINICORE - if( sockt->fd_max <= fd ) sockt->fd_max = fd + 1; +#ifndef SOCKET_EPOLL + // Select Based Event Dispatcher sFD_SET(fd,&readfds); +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher + epevent.data.fd = fd; + epevent.events = EPOLLIN; + + if(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &epevent) == SOCKET_ERROR){ + ShowError("connect_client: New Socket #%d failed to add to epoll event dispatcher: %s\n", fd, error_msg()); + sClose(fd); + return -1; + } + +#endif // SOCKET_EPOLL + + if( sockt->fd_max <= fd ) sockt->fd_max = fd + 1; + create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse); sockt->session[fd]->client_addr = ntohl(client_address.sin_addr.s_addr); @@ -586,8 +617,26 @@ int make_listen_bind(uint32 ip, uint16 port) exit(EXIT_FAILURE); } + +#ifndef SOCKET_EPOLL + // Select Based Event Dispatcher + sFD_SET(fd,&readfds); + +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher + epevent.data.fd = fd; + epevent.events = EPOLLIN; + + if(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &epevent) == SOCKET_ERROR){ + ShowError("make_listen_bind: failed to add listener socket #%d to epoll event dispatcher: %s\n", fd, error_msg()); + sClose(fd); + exit(EXIT_FAILURE); + } + +#endif // SOCKET_EPOLL + if(sockt->fd_max <= fd) sockt->fd_max = fd + 1; - sFD_SET(fd, &readfds); + create_session(fd, connect_client, null_send, null_parse); sockt->session[fd]->client_addr = 0; // just listens @@ -637,9 +686,26 @@ int make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { //Now the socket can be made non-blocking. [Skotlex] sockt->set_nonblocking(fd, 1); - if (sockt->fd_max <= fd) sockt->fd_max = fd + 1; + +#ifndef SOCKET_EPOLL + // Select Based Event Dispatcher sFD_SET(fd,&readfds); +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher + epevent.data.fd = fd; + epevent.events = EPOLLIN; + + if(epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &epevent) == SOCKET_ERROR){ + ShowError("make_connection: failed to add socket #%d to epoll event dispatcher: %s\n", fd, error_msg()); + sClose(fd); + return -1; + } + +#endif // SOCKET_EPOLL + + if(sockt->fd_max <= fd) sockt->fd_max = fd + 1; + create_session(fd, recv_to_fifo, send_from_fifo, default_func_parse); sockt->session[fd]->client_addr = ntohl(remote_address.sin_addr.s_addr); @@ -668,7 +734,7 @@ static void delete_session(int fd) #ifdef SHOW_SERVER_STATS socket_data_qi -= sockt->session[fd]->rdata_size - sockt->session[fd]->rdata_pos; socket_data_qo -= sockt->session[fd]->wdata_size; -#endif +#endif // SHOW_SERVER_STATS aFree(sockt->session[fd]->rdata); aFree(sockt->session[fd]->wdata); if( sockt->session[fd]->session_data ) @@ -741,7 +807,7 @@ int rfifoskip(int fd, size_t len) s->rdata_pos = s->rdata_pos + len; #ifdef SHOW_SERVER_STATS socket_data_qi -= len; -#endif +#endif // SHOW_SERVER_STATS return 0; } @@ -792,7 +858,7 @@ int wfifoset(int fd, size_t len) s->wdata_size += len; #ifdef SHOW_SERVER_STATS socket_data_qo += len; -#endif +#endif // SHOW_SERVER_STATS //If the interserver has 200% of its normal size full, flush the data. if( s->flag.server && s->wdata_size >= 2*FIFOSIZE_SERVERLINK ) sockt->flush(fd); @@ -806,22 +872,24 @@ int wfifoset(int fd, size_t len) #ifdef SEND_SHORTLIST send_shortlist_add_fd(fd); -#endif +#endif // SEND_SHORTLIST return 0; } int do_sockets(int next) { +#ifndef SOCKET_EPOLL fd_set rfd; struct timeval timeout; +#endif // SOCKET_EPOLL int ret,i; // PRESEND Timers are executed before do_sendrecv and can send packets and/or set sessions to eof. // Send remaining data and process client-side disconnects here. #ifdef SEND_SHORTLIST send_shortlist_do_sends(); -#else +#else // SEND_SHORTLIST for (i = 1; i < sockt->fd_max; i++) { if(!sockt->session[fd] @@ -830,7 +898,10 @@ int do_sockets(int next) if(sockt->session[fd]>wdata_size) sockt->session[fd]>func_send(i); } -#endif +#endif // SEND_SHORTLIST + +#ifndef SOCKET_EPOLL + // Select based Event Dispatcher: // can timeout until the next tick timeout.tv_sec = next/1000; @@ -848,6 +919,20 @@ int do_sockets(int next) } return 0; // interrupted by a signal, just loop and try again } +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher + + ret = epoll_wait(epfd, epevents, epoll_maxevents, next); + if(ret == SOCKET_ERROR) + { + if( sErrno != S_EINTR ) + { + ShowFatalError("do_sockets: epoll_wait() failed, %s!\n", error_msg()); + exit(EXIT_FAILURE); + } + return 0; // interrupted by a signal, just loop and try again + } +#endif // SOCKET_EPOLL sockt->last_tick = time(NULL); @@ -859,7 +944,33 @@ int do_sockets(int next) if( sockt->session[fd] ) sockt->session[fd]->func_recv(fd); } -#else +#elif defined(SOCKET_EPOLL) + // epoll based selection + + for( i = 0; i < ret; i++ ) + { + struct epoll_event *it = &epevents[i]; + struct socket_data *sock = sockt->session[ it->data.fd ]; + + if(!sock) + continue; + + if ((it->events & EPOLLERR) || + (it->events & EPOLLHUP) || + (!(it->events & EPOLLIN))) + { + // Got Error on this connection + sockt->eof( it->data.fd ); + + } else if (it->events & EPOLLIN) { + // data wainting + sock->func_recv( it->data.fd ); + + } + + } + +#else // defined(SOCKET_EPOLL) // otherwise assume that the fd_set is a bit-array and enumerate it in a standard way for( i = 1; ret && i < sockt->fd_max; ++i ) { @@ -869,12 +980,12 @@ int do_sockets(int next) --ret; } } -#endif +#endif // defined(SOCKET_EPOLL) // POSTSEND Send remaining data and handle eof sessions. #ifdef SEND_SHORTLIST send_shortlist_do_sends(); -#else +#else // SEND_SHORTLIST for (i = 1; i < sockt->fd_max; i++) { if(!sockt->session[i]) @@ -888,7 +999,7 @@ int do_sockets(int next) sockt->session[i]->func_parse(i); //This should close the session immediately. } } -#endif +#endif // SEND_SHORTLIST // parse input data on each socket for(i = 1; i < sockt->fd_max; i++) @@ -931,14 +1042,14 @@ int do_sockets(int next) sprintf(buf, "In: %.03f kB/s (%.03f kB/s, Q: %.03f kB) | Out: %.03f kB/s (%.03f kB/s, Q: %.03f kB) | RAM: %.03f MB", socket_data_i/1024., socket_data_ci/1024., socket_data_qi/1024., socket_data_o/1024., socket_data_co/1024., socket_data_qo/1024., iMalloc->usage()/1024.); #ifdef _WIN32 SetConsoleTitle(buf); -#else +#else // _WIN32 ShowMessage("\033[s\033[1;1H\033[2K%s\033[u", buf); -#endif +#endif // _WIN32 socket_data_last_tick = sockt->last_tick; socket_data_i = socket_data_ci = 0; socket_data_o = socket_data_co = 0; } -#endif +#endif // SHOW_SERVER_STATS return 0; } @@ -1160,7 +1271,7 @@ int access_ipmask(const char* str, AccessControl* acc) return 1; } ////////////////////////////// -#endif +#endif // MINICORE ////////////////////////////// int socket_config_read(const char* cfgName) @@ -1184,7 +1295,15 @@ int socket_config_read(const char* cfgName) sockt->stall_time = atoi(w2); if( sockt->stall_time < 3 ) sockt->stall_time = 3;/* a minimum is required to refrain it from killing itself */ + } +#ifdef SOCKET_EPOLL + else if(!strcmpi(w1, "epoll_maxevents")) { + epoll_maxevents = atoi(w2); + if(epoll_maxevents < 16){ + epoll_maxevents = 16; // minimum that seems to be useful + } } +#endif // SOCKET_EPOLL #ifndef MINICORE else if (!strcmpi(w1, "enable_ip_rules")) { ip_rules = config_switch(w2); @@ -1218,7 +1337,7 @@ int socket_config_read(const char* cfgName) access_debug = config_switch(w2); else if (!strcmpi(w1,"socket_max_client_packet")) socket_max_client_packet = strtoul(w2, NULL, 0); -#endif +#endif // MINICORE else if (!strcmpi(w1, "import")) socket_config_read(w2); else @@ -1239,7 +1358,7 @@ void socket_final(void) aFree(access_allow); if( access_deny ) aFree(access_deny); -#endif +#endif // MINICORE for( i = 1; i < sockt->fd_max; i++ ) if(sockt->session[i]) @@ -1255,6 +1374,18 @@ void socket_final(void) VECTOR_CLEAR(sockt->lan_subnets); VECTOR_CLEAR(sockt->allowed_ips); VECTOR_CLEAR(sockt->trusted_ips); + +#ifdef SOCKET_EPOLL + if(epfd != SOCKET_ERROR){ + close(epfd); + epfd = SOCKET_ERROR; + } + if(epevents != NULL){ + aFree(epevents); + epevents = NULL; + } +#endif // SOCKET_EPOLL + } /// Closes a socket. @@ -1264,7 +1395,17 @@ void socket_close(int fd) return;// invalid sockt->flush(fd); // Try to send what's left (although it might not succeed since it's a nonblocking socket) + +#ifndef SOCKET_EPOLL + // Select based Event Dispatcher sFD_CLR(fd, &readfds);// this needs to be done before closing the socket +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher + epevent.data.fd = fd; + epevent.events = EPOLLIN; + epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &epevent); // removing the socket from epoll when it's being closed is not required but recommended +#endif // SOCKET_EPOLL + sShutdown(fd, SHUT_RDWR); // Disallow further reads/writes sClose(fd); // We don't really care if these closing functions return an error, we are just shutting down and not reusing this socket. if (sockt->session[fd]) delete_session(fd); @@ -1401,20 +1542,39 @@ void socket_init(void) } } } -#endif +#endif // defined(HAVE_SETRLIMIT) && !defined(CYGWIN) // Get initial local ips sockt->naddr_ = sockt->getips(sockt->addr_,16); + socket_config_read(SOCKET_CONF_FILENAME); + +#ifndef SOCKET_EPOLL + // Select based Event Dispatcher: sFD_ZERO(&readfds); + ShowInfo("Server uses '" CL_WHITE "select" CL_RESET "' as event dispatcher\n"); + +#else // SOCKET_EPOLL + // Epoll based Event Dispatcher: + epfd = epoll_create(FD_SETSIZE); // 2.6.8 or newer ignores the expected socket amount argument + if(epfd == SOCKET_ERROR){ + ShowError("Failed to Create Epoll Event Dispatcher: %s\n", error_msg()); + exit(EXIT_FAILURE); + } + + memset(&epevent, 0x00, sizeof(struct epoll_event)); + epevents = aCalloc(epoll_maxevents, sizeof(struct epoll_event)); + + ShowInfo("Server uses '" CL_WHITE "epoll" CL_RESET "' with up to " CL_WHITE "%d" CL_RESET " events per cycle as event dispatcher\n", epoll_maxevents); + +#endif // SOCKET_EPOLL + #if defined(SEND_SHORTLIST) memset(send_shortlist_set, 0, sizeof(send_shortlist_set)); -#endif +#endif // defined(SEND_SHORTLIST) CREATE(sockt->session, struct socket_data *, FD_SETSIZE); - socket_config_read(SOCKET_CONF_FILENAME); - // initialize last send-receive tick sockt->last_tick = time(NULL); @@ -1427,7 +1587,7 @@ void socket_init(void) connect_history = uidb_alloc(DB_OPT_RELEASE_DATA); timer->add_func_list(connect_check_clear, "connect_check_clear"); timer->add_interval(timer->gettick()+1000, connect_check_clear, 0, 0, 5*60*1000); -#endif +#endif // MINICORE ShowInfo("Server supports up to '"CL_WHITE"%"PRIu64""CL_RESET"' concurrent connections.\n", rlim_cur); } @@ -1617,7 +1777,7 @@ void send_shortlist_do_sends(void) } } } -#endif +#endif // SEND_SHORTLIST /** * Checks whether the given IP comes from LAN or WAN. @@ -1752,10 +1912,12 @@ void socket_net_config_read(const char *filename) ShowError("No allowed server IP ranges configured. This server won't be able to accept connections from any char servers.\n"); } ARR_FIND(0, VECTOR_LENGTH(sockt->allowed_ips), i, SUBNET_MATCH(0, VECTOR_INDEX(sockt->allowed_ips, i).ip, VECTOR_INDEX(sockt->allowed_ips, i).mask)); +#ifndef BUILDBOT if (i != VECTOR_LENGTH(sockt->allowed_ips)) { ShowWarning("Using a wildcard IP range in the allowed server IPs is NOT RECOMMENDED.\n"); ShowNotice("Please edit your '%s' allowed list to fit your network configuration.\n", filename); } +#endif // BUILDBOT libconfig->destroy(&network_config); return; } diff --git a/src/common/sql.c b/src/common/sql.c index 1eae1b29b..9a90f9807 100644 --- a/src/common/sql.c +++ b/src/common/sql.c @@ -778,8 +778,6 @@ int SqlStmt_NextRow(struct SqlStmt *self) // check for errors if (err == MYSQL_NO_DATA) return SQL_NO_DATA; -#if defined(MYSQL_DATA_TRUNCATED) - // MySQL 5.0/5.1 defines and returns MYSQL_DATA_TRUNCATED [FlavioJS] if (err == MYSQL_DATA_TRUNCATED) { my_bool truncated; @@ -804,7 +802,6 @@ int SqlStmt_NextRow(struct SqlStmt *self) ShowSQL("DB error - data truncated (unknown source)\n"); return SQL_ERROR; } -#endif if (err) { ShowSQL("DB error - %s\n", mysql_stmt_error(self->stmt)); hercules_mysql_error_handler(mysql_stmt_errno(self->stmt)); @@ -816,18 +813,6 @@ int SqlStmt_NextRow(struct SqlStmt *self) for (i = 0; i < cols; ++i) { unsigned long length = self->column_lengths[i].length; MYSQL_BIND *column = &self->columns[i]; -#if !defined(MYSQL_DATA_TRUNCATED) - // MySQL 4.1/(below?) returns success even if data is truncated, so we test truncation manually [FlavioJS] - if (column->buffer_length < length) { - // report truncated column - if (column->buffer_type == MYSQL_TYPE_STRING || column->buffer_type == MYSQL_TYPE_BLOB) { - // string/enum/blob column - SqlStmt_P_ShowDebugTruncatedColumn(self, i); - return SQL_ERROR; - } - // FIXME numeric types and null [FlavioJS] - } -#endif if (self->column_lengths[i].out_length) *self->column_lengths[i].out_length = (uint32)length; if (column->buffer_type == MYSQL_TYPE_STRING) { @@ -880,10 +865,10 @@ void SqlStmt_Free(struct SqlStmt *self) } /* receives mysql error codes during runtime (not on first-time-connects) */ void hercules_mysql_error_handler(unsigned int ecode) { - static unsigned int retry = 1; switch( ecode ) { case 2003:/* Can't connect to MySQL (this error only happens here when failing to reconnect) */ if( mysql_reconnect_type == 1 ) { + static unsigned int retry = 1; if( ++retry > mysql_reconnect_count ) { ShowFatalError("MySQL has been unreachable for too long, %u reconnects were attempted. Shutting Down\n", retry); exit(EXIT_FAILURE); diff --git a/src/common/strlib.c b/src/common/strlib.c index 8f164f2e9..b67adb63c 100644 --- a/src/common/strlib.c +++ b/src/common/strlib.c @@ -271,10 +271,9 @@ char* strlib_strtok_r(char *s1, const char *s2, char **lasts) size_t strlib_strnlen(const char *string, size_t maxlen) { -// TODO: The _MSC_VER check can probably be removed (we no longer support VS -// versions <= 2003, do we?), but this implementation might be still necessary -// for NetBSD 5.x and possibly some Solaris versions. -#if !(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN) +// TODO: Verify whether this implementation is still necessary for NetBSD 5.x +// and possibly some Solaris versions. +#if !(defined(WIN32) && defined(_MSC_VER)) && !defined(HAVE_STRNLEN) /* Find the length of STRING, but scan at most MAXLEN characters. * If no '\0' terminator is found in that many characters, return MAXLEN. */ @@ -629,6 +628,7 @@ int sv_parse(const char* str, int len, int startoff, char delim, int* out_pos, i svstate.opt = opt; svstate.delim = delim; svstate.done = false; + svstate.start = 0; // parse count = 0; @@ -772,6 +772,7 @@ size_t sv_escape_c(char* out_dest, const char* src, size_t len, const char* esca case '\v': out_dest[j++] = 'v'; break; case '\f': out_dest[j++] = 'f'; break; case '\?': out_dest[j++] = '?'; break; + case '\"': out_dest[j++] = '"'; break; default:// to octal out_dest[j++] = '0'+((char)(((unsigned char)src[i]&0700)>>6)); out_dest[j++] = '0'+((char)(((unsigned char)src[i]&0070)>>3)); @@ -1113,7 +1114,7 @@ void strlib_defaults(void) { strlib->normalize_name_ = strlib_normalize_name; strlib->stristr_ = strlib_stristr; -#if !(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN) +#if !(defined(WIN32) && defined(_MSC_VER)) && !defined(HAVE_STRNLEN) strlib->strnlen_ = strlib_strnlen; #else strlib->strnlen_ = NULL; diff --git a/src/common/strlib.h b/src/common/strlib.h index 36dceef2d..fa7d577eb 100644 --- a/src/common/strlib.h +++ b/src/common/strlib.h @@ -33,7 +33,7 @@ #define normalize_name(str,delims) (strlib->normalize_name_((str),(delims))) #define stristr(haystack,needle) (strlib->stristr_((haystack),(needle))) -#if !(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN) +#if !(defined(WIN32) && defined(_MSC_VER)) && !defined(HAVE_STRNLEN) #define strnlen(string,maxlen) (strlib->strnlen_((string),(maxlen))) #endif @@ -98,7 +98,7 @@ struct strlib_interface { char *(*normalize_name_) (char* str,const char* delims); const char *(*stristr_) (const char *haystack, const char *needle); - /* only used when '!(defined(WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) && !defined(HAVE_STRNLEN)', needs to be defined at all times however */ + /* only used when '!(defined(WIN32) && defined(_MSC_VER)) && !defined(HAVE_STRNLEN)', needs to be defined at all times however */ size_t (*strnlen_) (const char* string, size_t maxlen); /* only used when 'WIN32' */ diff --git a/src/common/sysinfo.c b/src/common/sysinfo.c index 95f423ff7..aeb8d8e71 100644 --- a/src/common/sysinfo.c +++ b/src/common/sysinfo.c @@ -291,40 +291,6 @@ bool sysinfo_svn_get_revision(char **out) { if (*out != NULL) return true; } - - // subversion 1.6 and older? - if ((fp = fopen(".svn/entries", "r")) != NULL) { - char line[1024]; - int rev; - // Check the version - if (fgets(line, sizeof(line), fp)) { - if (!ISDIGIT(line[0])) { - // XML File format - while (fgets(line,sizeof(line),fp)) - if (strstr(line,"revision=")) break; - if (sscanf(line," %*[^\"]\"%d%*[^\n]", &rev) == 1) { - if (*out != NULL) - aFree(*out); - *out = aCalloc(1, 8); - snprintf(*out, 8, "%d", rev); - } - } else { - // Bin File format - if (fgets(line, sizeof(line), fp) == NULL) { printf("Can't get bin name\n"); } // Get the name - if (fgets(line, sizeof(line), fp) == NULL) { printf("Can't get entries kind\n"); } // Get the entries kind - if (fgets(line, sizeof(line), fp)) { // Get the rev numver - if (*out != NULL) - aFree(*out); - *out = aCalloc(1, 8); - snprintf(*out, 8, "%d", atoi(line)); - } - } - } - fclose(fp); - - if (*out != NULL) - return true; - } #endif if (*out != NULL) aFree(*out); diff --git a/src/common/timer.c b/src/common/timer.c index e7a57481a..0b28f6a06 100644 --- a/src/common/timer.c +++ b/src/common/timer.c @@ -51,7 +51,7 @@ struct timer_interface *timer; // timers (array) static struct TimerData* timer_data = NULL; static int timer_data_max = 0; -static int timer_data_num = 0; +static int timer_data_num = 1; // free timers (array) static int* free_timer_list = NULL; @@ -369,6 +369,7 @@ int timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int in /// Retrieves internal timer data const struct TimerData* timer_get(int tid) { + Assert_retr(NULL, tid > 0); return ( tid >= 0 && tid < timer_data_num ) ? &timer_data[tid] : NULL; } @@ -379,7 +380,7 @@ int timer_do_delete(int tid, TimerFunc func) { nullpo_ret(func); - if( tid < 0 || tid >= timer_data_num ) { + if (tid < 1 || tid >= timer_data_num) { ShowError("timer_do_delete error : no such timer [%d](%p(%s))\n", tid, func, search_timer_func_list(func)); Assert_retr(-1, 0); return -1; @@ -406,6 +407,11 @@ int timer_do_delete(int tid, TimerFunc func) /// Adjusts a timer's expiration time. /// Returns the new tick value, or -1 if it fails. int64 timer_addtick(int tid, int64 tick) { + if (tid < 1 || tid >= timer_data_num) { + ShowError("timer_addtick error : no such timer [%d]\n", tid); + Assert_retr(-1, 0); + return -1; + } return timer->settick(tid, timer_data[tid].tick+tick); } diff --git a/src/config/core.h b/src/config/core.h index 09954e0cb..afd138a43 100644 --- a/src/config/core.h +++ b/src/config/core.h @@ -40,6 +40,17 @@ /// your map-server using more resources while this is active, comment the line #define SCRIPT_CALLFUNC_CHECK +/** + * Strip linebreaks from `mes` dialogs. + * + * Leave this line commented out to keep the hard line-breaks (`\r`) in the + * displayed `mes` dialogs (as in official servers). + * Uncomment it to strip the line-breaks and replace them with spaces, letting + * the client automatically wrap text in dialogs, depending on font size and + * dialog window size (may work better for clients using a non-standard font). + */ +//#define SCRIPT_MES_STRIP_LINEBREAK + /// Comment to disable Hercules' console_parse /// CONSOLE_INPUT allows you to type commands into the server's console, /// Disabling it saves one thread. diff --git a/src/login/Makefile.in b/src/login/Makefile.in index 274a82fc8..c74ed1e10 100644 --- a/src/login/Makefile.in +++ b/src/login/Makefile.in @@ -23,7 +23,7 @@ CONFIG_D = ../config CONFIG_H = $(wildcard $(CONFIG_D)/*.h) $(wildcard $(CONFIG_D)/*/*.h) COMMON_D = ../common -COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) +COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) ../plugins/HPMHooking.h SYSINFO_INC = $(COMMON_D)/sysinfo.inc COMMON_INCLUDE = -I.. diff --git a/src/login/account_sql.c b/src/login/account_sql.c index 195a10233..1e19b5a37 100644 --- a/src/login/account_sql.c +++ b/src/login/account_sql.c @@ -606,9 +606,9 @@ static bool mmo_auth_fromsql(AccountDB_SQL* db, struct mmo_account* acc, int acc SQL->GetData(sql_handle, 7, &data, NULL); acc->unban_time = atol(data); SQL->GetData(sql_handle, 8, &data, NULL); acc->expiration_time = atol(data); SQL->GetData(sql_handle, 9, &data, NULL); acc->logincount = (unsigned int)strtoul(data, NULL, 10); - SQL->GetData(sql_handle, 10, &data, NULL); safestrncpy(acc->lastlogin, data, sizeof(acc->lastlogin)); + SQL->GetData(sql_handle, 10, &data, NULL); safestrncpy(acc->lastlogin, data != NULL ? data : "", sizeof(acc->lastlogin)); SQL->GetData(sql_handle, 11, &data, NULL); safestrncpy(acc->last_ip, data, sizeof(acc->last_ip)); - SQL->GetData(sql_handle, 12, &data, NULL); safestrncpy(acc->birthdate, data, sizeof(acc->birthdate)); + SQL->GetData(sql_handle, 12, &data, NULL); safestrncpy(acc->birthdate, data != NULL ? data : "", sizeof(acc->birthdate)); SQL->GetData(sql_handle, 13, &data, NULL); acc->char_slots = (uint8)atoi(data); SQL->GetData(sql_handle, 14, &data, NULL); safestrncpy(acc->pincode, data, sizeof(acc->pincode)); SQL->GetData(sql_handle, 15, &data, NULL); acc->pincode_change = (unsigned int)atol(data); diff --git a/src/login/login.c b/src/login/login.c index d7c7321d8..49508d564 100644 --- a/src/login/login.c +++ b/src/login/login.c @@ -1671,6 +1671,19 @@ static CMDLINEARG(loginconfig) login->LOGIN_CONF_NAME = aStrdup(params); return true; } + +/** + * --run-once handler + * + * Causes the server to run its loop once, and shutdown. Useful for testing. + * @see cmdline->exec + */ +static CMDLINEARG(runonce) +{ + core->runflag = CORE_ST_STOP; + return true; +} + /** * --net-config handler * @@ -1688,6 +1701,7 @@ static CMDLINEARG(netconfig) */ void cmdline_args_init_local(void) { + CMDLINEARG_DEF2(run-once, runonce, "Closes server after loading (testing).", CMDLINE_OPT_NORMAL); CMDLINEARG_DEF2(login-config, loginconfig, "Alternative login-server configuration.", CMDLINE_OPT_PARAM); CMDLINEARG_DEF2(net-config, netconfig, "Alternative subnet configuration.", CMDLINE_OPT_PARAM); } diff --git a/src/map/Makefile.in b/src/map/Makefile.in index ff582d2f9..3c6a3f806 100644 --- a/src/map/Makefile.in +++ b/src/map/Makefile.in @@ -23,7 +23,7 @@ CONFIG_D = ../config CONFIG_H = $(wildcard $(CONFIG_D)/*.h) $(wildcard $(CONFIG_D)/*/*.h) COMMON_D = ../common -COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) +COMMON_H = $(filter-out %.p.h, $(wildcard $(COMMON_D)/*.h)) ../plugins/HPMHooking.h SYSINFO_INC = $(COMMON_D)/sysinfo.inc COMMON_INCLUDE = -I.. diff --git a/src/map/atcommand.c b/src/map/atcommand.c index 3da5c203f..eef67189a 100644 --- a/src/map/atcommand.c +++ b/src/map/atcommand.c @@ -132,7 +132,6 @@ bool msg_config_read(const char *cfg_name, bool allow_override) { int msg_number; char line[1024], w1[1024], w2[1024]; FILE *fp; - static int called = 1; nullpo_retr(false, cfg_name); if ((fp = fopen(cfg_name, "r")) == NULL) { @@ -170,21 +169,6 @@ bool msg_config_read(const char *cfg_name, bool allow_override) { } fclose(fp); - if( ++called == 1 ) { //Original - if( script->lang_export_fp ) { - int i; - for(i = 0; i < MAX_MSG;i++) { - if( atcommand->msg_table[0][i] != NULL ) { - fprintf(script->lang_export_fp, "msgctxt \"messages.conf\"\n" - "msgid \"%s\"\n" - "msgstr \"\"\n", - atcommand->msg_table[0][i] - ); - } - } - } - } - return true; } @@ -266,22 +250,22 @@ ACMD(send) clif->message(fd, atcmd_output); return false; } - + if (len) { // show packet length safesnprintf(atcmd_output, sizeof(atcmd_output), msg_fd(fd,904), type, clif->packet(type)->len); // Packet 0x%x length: %d clif->message(fd, atcmd_output); return true; } - + len = clif->packet(type)->len; - + if (len == -1) { // dynamic packet len = SHRT_MAX-4; // maximum length off = 4; } - + WFIFOHEAD(sd->fd, len); WFIFOW(sd->fd,0)=TOW(type); @@ -1091,9 +1075,9 @@ ACMD(kami) sscanf(message, "%199[^\n]", atcmd_output); if (stristr(info->command, "l") != NULL) - clif->broadcast(&sd->bl, atcmd_output, strlen(atcmd_output) + 1, BC_DEFAULT, ALL_SAMEMAP); + clif->broadcast(&sd->bl, atcmd_output, (int)strlen(atcmd_output) + 1, BC_DEFAULT, ALL_SAMEMAP); else - intif->broadcast(atcmd_output, strlen(atcmd_output) + 1, (*(info->command + 4) == 'b' || *(info->command + 4) == 'B') ? BC_BLUE : BC_YELLOW); + intif->broadcast(atcmd_output, (int)strlen(atcmd_output) + 1, (*(info->command + 4) == 'b' || *(info->command + 4) == 'B') ? BC_BLUE : BC_YELLOW); } else { if(!*message || (sscanf(message, "%10u %199[^\n]", &color, atcmd_output) < 2)) { clif->message(fd, msg_fd(fd,981)); // Please enter color and message (usage: @kamic <color> <message>). @@ -1104,7 +1088,7 @@ ACMD(kami) clif->message(fd, msg_fd(fd,982)); // Invalid color. return false; } - intif->broadcast2(atcmd_output, strlen(atcmd_output) + 1, color, 0x190, 12, 0, 0); + intif->broadcast2(atcmd_output, (int)strlen(atcmd_output) + 1, color, 0x190, 12, 0, 0); } return true; } @@ -3748,7 +3732,7 @@ ACMD(reloadscript) { * 1 = Show users in that map and their location * 2 = Shows NPCs in that map * 3 = Shows the chats in that map - TODO# add the missing mapflags e.g. adjust_skill_damage to display + * TODO# add the missing mapflags e.g. adjust_skill_damage to display *------------------------------------------*/ ACMD(mapinfo) { @@ -3793,7 +3777,7 @@ ACMD(mapinfo) if( pl_sd->mapindex == m_index ) { if( pl_sd->state.vending ) vend_num++; - else if ((cd = map->id2cd(pl_sd->chatID)) != NULL && cd->usersd[0] == pl_sd) + else if ((cd = map->id2cd(pl_sd->chat_id)) != NULL && cd->usersd[0] == pl_sd) chat_num++; } } @@ -3972,7 +3956,7 @@ ACMD(mapinfo) clif->message(fd, msg_fd(fd,1113)); // ----- Chats in Map ----- iter = mapit_getallusers(); for (pl_sd = BL_UCCAST(BL_PC, mapit->first(iter)); mapit->exists(iter); pl_sd = BL_UCCAST(BL_PC, mapit->next(iter))) { - if ((cd = map->id2cd(pl_sd->chatID)) != NULL && pl_sd->mapindex == m_index && cd->usersd[0] == pl_sd) { + if ((cd = map->id2cd(pl_sd->chat_id)) != NULL && pl_sd->mapindex == m_index && cd->usersd[0] == pl_sd) { safesnprintf(atcmd_output, sizeof(atcmd_output), msg_fd(fd,1114), // Chat: %s | Player: %s | Location: %d %d cd->title, pl_sd->status.name, cd->bl.x, cd->bl.y); clif->message(fd, atcmd_output); @@ -4153,8 +4137,9 @@ ACMD(repairall) count = 0; for (i = 0; i < MAX_INVENTORY; i++) { - if (sd->status.inventory[i].nameid && sd->status.inventory[i].attribute == 1) { - sd->status.inventory[i].attribute = 0; + if (sd->status.inventory[i].nameid && (sd->status.inventory[i].attribute & ATTR_BROKEN) != 0) { + sd->status.inventory[i].attribute |= ATTR_BROKEN; + sd->status.inventory[i].attribute ^= ATTR_BROKEN; clif->produce_effect(sd, 0, sd->status.inventory[i].nameid); count++; } @@ -4911,7 +4896,7 @@ ACMD(broadcast) } safesnprintf(atcmd_output, sizeof(atcmd_output), "%s: %s", sd->status.name, message); - intif->broadcast(atcmd_output, strlen(atcmd_output) + 1, BC_DEFAULT); + intif->broadcast(atcmd_output, (int)strlen(atcmd_output) + 1, BC_DEFAULT); return true; } @@ -4930,7 +4915,7 @@ ACMD(localbroadcast) safesnprintf(atcmd_output, sizeof(atcmd_output), "%s: %s", sd->status.name, message); - clif->broadcast(&sd->bl, atcmd_output, strlen(atcmd_output) + 1, BC_DEFAULT, ALL_SAMEMAP); + clif->broadcast(&sd->bl, atcmd_output, (int)strlen(atcmd_output) + 1, BC_DEFAULT, ALL_SAMEMAP); return true; } @@ -6779,7 +6764,7 @@ ACMD(showmobs) clif->message(fd, atcmd_output); it = mapit_geteachmob(); - for (md = BL_UCCAST(BL_MOB, mapit->first(it)); mapit->next(it); md = BL_UCCAST(BL_MOB, mapit->next(it))) { + for (md = BL_UCCAST(BL_MOB, mapit->first(it)); mapit->exists(it); md = BL_UCCAST(BL_MOB, mapit->next(it))) { if( md->bl.m != sd->bl.m ) continue; if( mob_id != -1 && md->class_ != mob_id ) @@ -7836,7 +7821,7 @@ ACMD(cash) // If this option is set, the message is already sent by pc function if( !battle_config.cashshop_show_points ){ sprintf(output, msg_fd(fd,505), ret, sd->cashPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); clif->message(fd, output); } } else @@ -7844,7 +7829,7 @@ ACMD(cash) } else { if( (ret=pc->paycash(sd, -value, 0)) >= 0){ sprintf(output, msg_fd(fd,410), ret, sd->cashPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); clif->message(fd, output); } else clif->message(fd, msg_fd(fd,41)); // Unable to decrease the number/value. @@ -7855,7 +7840,7 @@ ACMD(cash) // If this option is set, the message is already sent by pc function if( !battle_config.cashshop_show_points ){ sprintf(output, msg_fd(fd,506), ret, sd->kafraPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); clif->message(fd, output); } } else @@ -7863,7 +7848,7 @@ ACMD(cash) } else { if( (ret=pc->paycash(sd, -value, -value)) >= 0){ sprintf(output, msg_fd(fd,411), ret, sd->kafraPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); clif->message(fd, output); } else clif->message(fd, msg_fd(fd,41)); // Unable to decrease the number/value. @@ -7958,7 +7943,7 @@ ACMD(request) safesnprintf(atcmd_output, sizeof(atcmd_output), msg_fd(fd,278), message); // (@request): %s intif->wis_message_to_gm(sd->status.name, PC_PERM_RECEIVE_REQUESTS, atcmd_output); - clif_disp_onlyself(sd, atcmd_output, strlen(atcmd_output)); + clif_disp_onlyself(sd, atcmd_output); clif->message(sd->fd,msg_fd(fd,279)); // @request sent. return true; } diff --git a/src/map/atcommand.h b/src/map/atcommand.h index 0e7895825..ef8be7807 100644 --- a/src/map/atcommand.h +++ b/src/map/atcommand.h @@ -152,7 +152,8 @@ void atcommand_defaults(void); HPShared struct atcommand_interface *atcommand; /* stay here */ -#define ACMD(x) static bool atcommand_ ## x (const int fd, struct map_session_data* sd, const char* command, const char* message, struct AtCommandInfo *info) __attribute__((nonnull (2, 3, 4, 5))); \ - static bool atcommand_ ## x (const int fd, struct map_session_data* sd, const char* command, const char* message, struct AtCommandInfo *info) +#define ACMD(x) \ + static bool atcommand_ ## x (const int fd, struct map_session_data* sd, const char* command, const char* message, struct AtCommandInfo *info) __attribute__((nonnull (2, 3, 4, 5))); \ + static bool atcommand_ ## x (const int fd, struct map_session_data* sd, const char* command, const char* message, struct AtCommandInfo *info) #endif /* MAP_ATCOMMAND_H */ diff --git a/src/map/battle.c b/src/map/battle.c index a7a6f4719..944271efa 100644 --- a/src/map/battle.c +++ b/src/map/battle.c @@ -3512,8 +3512,6 @@ int battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) { struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag) { int nk; short s_ele = 0; - unsigned int skillratio = 100; //Skill dmg modifiers. - struct map_session_data *sd = NULL; struct status_change *sc; struct Damage ad; @@ -3666,6 +3664,7 @@ struct Damage battle_calc_magic_attack(struct block_list *src,struct block_list ad.damage = status->get_lv(src) * 10 + sstatus->int_; break; default: { + unsigned int skillratio = 100; //Skill dmg modifiers. MATK_ADD( status->get_matk(src, 2) ); #ifdef RENEWAL ad.damage = battle->calc_cardfix(BF_MAGIC, src, target, nk, s_ele, 0, ad.damage, 0, ad.flag); @@ -4276,7 +4275,6 @@ void battle_calc_misc_attack_unknown(struct block_list *src, struct block_list * // FIXME: wflag is undocumented struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int wflag) { - unsigned int skillratio = 100; //Skill dmg modifiers. short temp=0; short s_ele, s_ele_; int i, nk; @@ -4775,6 +4773,7 @@ struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list } //End hit/miss calculation if (flag.hit && !flag.infdef) { //No need to do the math for plants + unsigned int skillratio = 100; //Skill dmg modifiers. //Hitting attack //Assuming that 99% of the cases we will not need to check for the flag.rh... we don't. @@ -6010,6 +6009,46 @@ int battle_damage_area(struct block_list *bl, va_list ap) { return 0; } + +bool battle_check_arrows(struct map_session_data *sd) +{ + int index = sd->equip_index[EQI_AMMO]; + if (index < 0) { + if (sd->weapontype1 > W_KATAR && sd->weapontype1 < W_HUUMA) + clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); + else + clif->arrow_fail(sd, 0); + return false; + } + //Ammo check by Ishizu-chan + if (sd->inventory_data[index]) { + switch (sd->status.weapon) { + case W_BOW: + if (sd->inventory_data[index]->look != A_ARROW) { + clif->arrow_fail(sd, 0); + return false; + } + break; + case W_REVOLVER: + case W_RIFLE: + case W_GATLING: + case W_SHOTGUN: + if (sd->inventory_data[index]->look != A_BULLET) { + clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); + return false; + } + break; + case W_GRENADE: + if (sd->inventory_data[index]->look != A_GRENADE) { + clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); + return false; + } + break; + } + } + return true; +} + /*========================================== * Do a basic physical attack (call trough unit_attack_timer) *------------------------------------------*/ @@ -6047,39 +6086,8 @@ enum damage_lv battle_weapon_attack(struct block_list* src, struct block_list* t sd->state.arrow_atk = (sd->status.weapon == W_BOW || (sd->status.weapon >= W_REVOLVER && sd->status.weapon <= W_GRENADE)); if (sd->state.arrow_atk) { - int index = sd->equip_index[EQI_AMMO]; - if (index<0) { - if ( sd->weapontype1 > W_KATAR && sd->weapontype1 < W_HUUMA ) - clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); - else - clif->arrow_fail(sd, 0); + if (battle->check_arrows(sd) == false) return ATK_NONE; - } - //Ammo check by Ishizu-chan - if (sd->inventory_data[index]) - switch (sd->status.weapon) { - case W_BOW: - if (sd->inventory_data[index]->look != A_ARROW) { - clif->arrow_fail(sd,0); - return ATK_NONE; - } - break; - case W_REVOLVER: - case W_RIFLE: - case W_GATLING: - case W_SHOTGUN: - if (sd->inventory_data[index]->look != A_BULLET) { - clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); - return ATK_NONE; - } - break; - case W_GRENADE: - if (sd->inventory_data[index]->look != A_GRENADE) { - clif->skill_fail(sd, 0, USESKILL_FAIL_NEED_MORE_BULLET, 0); - return ATK_NONE; - } - break; - } } } if (sc && sc->count) { @@ -7606,6 +7614,7 @@ void battle_defaults(void) { battle->calc_gvg_damage = battle_calc_gvg_damage; battle->calc_bg_damage = battle_calc_bg_damage; battle->weapon_attack = battle_weapon_attack; + battle->check_arrows = battle_check_arrows; battle->calc_weapon_attack = battle_calc_weapon_attack; battle->delay_damage = battle_delay_damage; battle->drain = battle_drain; diff --git a/src/map/battle.h b/src/map/battle.h index 49abdc730..6fa600ada 100644 --- a/src/map/battle.h +++ b/src/map/battle.h @@ -593,6 +593,8 @@ struct battle_interface { int64 (*calc_bg_damage) (struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); /* normal weapon attack */ enum damage_lv (*weapon_attack) (struct block_list *bl, struct block_list *target, int64 tick, int flag); + /* check is equipped ammo and this ammo allowed */ + bool (*check_arrows) (struct map_session_data *sd); /* calculate weapon attack */ struct Damage (*calc_weapon_attack) (struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int wflag); /* delays damage or skills by a timer */ diff --git a/src/map/battleground.c b/src/map/battleground.c index 629122c87..5231ce3d2 100644 --- a/src/map/battleground.c +++ b/src/map/battleground.c @@ -171,7 +171,7 @@ int bg_team_leave(struct map_session_data *sd, enum bg_team_leave_type flag) { sprintf(output, "Server : %s has been afk-kicked from the battlefield...", sd->status.name); break; } - clif->bg_message(bgd, 0, "Server", output, strlen(output) + 1); + clif->bg_message(bgd, 0, "Server", output); } if( bgd->logout_event[0] && flag ) @@ -265,14 +265,15 @@ int bg_team_get_id(struct block_list *bl) { return 0; } -bool bg_send_message(struct map_session_data *sd, const char *mes, int len) { +bool bg_send_message(struct map_session_data *sd, const char *mes) +{ struct battleground_data *bgd; nullpo_ret(sd); nullpo_ret(mes); if( sd->bg_id == 0 || (bgd = bg->team_search(sd->bg_id)) == NULL ) return false; // Couldn't send message - clif->bg_message(bgd, sd->bl.id, sd->status.name, mes, len); + clif->bg_message(bgd, sd->bl.id, sd->status.name, mes); return true; } diff --git a/src/map/battleground.h b/src/map/battleground.h index 8657beaf8..4c3d4878f 100644 --- a/src/map/battleground.h +++ b/src/map/battleground.h @@ -130,7 +130,7 @@ struct battleground_interface { bool (*member_respawn) (struct map_session_data *sd); int (*create) (unsigned short map_index, short rx, short ry, const char *ev, const char *dev); int (*team_get_id) (struct block_list *bl); - bool (*send_message) (struct map_session_data *sd, const char *mes, int len); + bool (*send_message) (struct map_session_data *sd, const char *mes); int (*send_xy_timer_sub) (union DBKey key, struct DBData *data, va_list ap); int (*send_xy_timer) (int tid, int64 tick, int id, intptr_t data); int (*afk_timer) (int tid, int64 tick, int id, intptr_t data); diff --git a/src/map/channel.c b/src/map/channel.c index 3d1b3f975..ee8242b23 100644 --- a/src/map/channel.c +++ b/src/map/channel.c @@ -609,7 +609,10 @@ void read_channels_config(void) local_autojoin = 0, ally_autojoin = 0, allow_user_channel_creation = 0, irc_enabled = 0, - irc_autojoin = 0; + irc_autojoin = 0, + irc_flood_protection_rate = 0, + irc_flood_protection_burst = 0, + irc_flood_protection_enabled = 0; if( !libconfig->setting_lookup_string(settings, "map_local_channel_name", &local_name) ) local_name = "map"; @@ -640,58 +643,52 @@ void read_channels_config(void) const char *irc_server, *irc_channel, *irc_nick, *irc_nick_pw; int irc_use_ghost = 0; - if( libconfig->setting_lookup_string(settings, "irc_channel_network", &irc_server) ) { - if( !strstr(irc_server,":") ) { + if (!libconfig->setting_lookup_string(settings, "irc_channel_network", &irc_server)) { + channel->config->irc = false; + ShowWarning("channels.conf : irc channel enabled but irc_channel_network wasn't found, disabling irc channel...\n"); + } else { + char *server = aStrdup(irc_server); + char *port = strchr(server, ':'); + if (port == NULL) { channel->config->irc = false; - ShowWarning("channels.conf : network port wasn't found in 'irc_channel_network', disabling irc channel...\n"); + ShowWarning("channels.conf: network port wasn't found in 'irc_channel_network', disabling irc channel...\n"); + } else if ((size_t)(port-server) > sizeof channel->config->irc_server - 1) { + channel->config->irc = false; + ShowWarning("channels.conf: server name is too long in 'irc_channel_network', disabling irc channel...\n"); } else { - unsigned char d = 0, dlen = strlen(irc_server); - char server[40]; - if (dlen > 39) - dlen = 39; - memset(server, '\0', sizeof(server)); - - for(d = 0; d < dlen; d++) { - if(irc_server[d] == ':') { - memcpy(server, irc_server, d); - safestrncpy(channel->config->irc_server, server, 40); - memcpy(server, &irc_server[d+1], dlen - d - 1); - channel->config->irc_server_port = atoi(server); - break; - } - } + *port = '\0'; + port++; + safestrncpy(channel->config->irc_server, server, sizeof channel->config->irc_server); + channel->config->irc_server_port = atoi(port); } - } else { - channel->config->irc = false; - ShowWarning("channels.conf : irc channel enabled but irc_channel_network wasn't found, disabling irc channel...\n"); + aFree(server); } - if( libconfig->setting_lookup_string(settings, "irc_channel_channel", &irc_channel) ) + if (libconfig->setting_lookup_string(settings, "irc_channel_channel", &irc_channel)) { safestrncpy(channel->config->irc_channel, irc_channel, 50); - else { + } else { channel->config->irc = false; ShowWarning("channels.conf : irc channel enabled but irc_channel_channel wasn't found, disabling irc channel...\n"); } - if( libconfig->setting_lookup_string(settings, "irc_channel_nick", &irc_nick) ) { - if( strcmpi(irc_nick,"Hercules_chSysBot") == 0 ) { + if (libconfig->setting_lookup_string(settings, "irc_channel_nick", &irc_nick)) { + if (strcmpi(irc_nick,"Hercules_chSysBot") == 0) { sprintf(channel->config->irc_nick, "Hercules_chSysBot%d",rnd()%777); - } else + } else { safestrncpy(channel->config->irc_nick, irc_nick, 40); + } } else { channel->config->irc = false; ShowWarning("channels.conf : irc channel enabled but irc_channel_nick wasn't found, disabling irc channel...\n"); } - if( libconfig->setting_lookup_string(settings, "irc_channel_nick_pw", &irc_nick_pw) ) { + if (libconfig->setting_lookup_string(settings, "irc_channel_nick_pw", &irc_nick_pw)) { safestrncpy(channel->config->irc_nick_pw, irc_nick_pw, 30); config_setting_lookup_bool(settings, "irc_channel_use_ghost", &irc_use_ghost); channel->config->irc_use_ghost = irc_use_ghost; } - } libconfig->setting_lookup_bool(settings, "map_local_channel_autojoin", &local_autojoin); libconfig->setting_lookup_bool(settings, "ally_channel_autojoin", &ally_autojoin); libconfig->setting_lookup_bool(settings, "irc_channel_autojoin", &irc_autojoin); - if (local_autojoin) channel->config->local_autojoin = true; if (ally_autojoin) @@ -699,6 +696,26 @@ void read_channels_config(void) if (irc_autojoin) channel->config->irc_autojoin = true; + libconfig->setting_lookup_bool(settings, "irc_flood_protection_enabled", &irc_flood_protection_enabled); + + if (irc_flood_protection_enabled) { + ircbot->flood_protection_enabled = true; + + libconfig->setting_lookup_int(settings, "irc_flood_protection_rate", &irc_flood_protection_rate); + libconfig->setting_lookup_int(settings, "irc_flood_protection_burst", &irc_flood_protection_burst); + + if (irc_flood_protection_rate > 0) + ircbot->flood_protection_rate = irc_flood_protection_rate; + else + ircbot->flood_protection_rate = 1000; + if (irc_flood_protection_burst > 0) + ircbot->flood_protection_burst = irc_flood_protection_burst; + else + ircbot->flood_protection_burst = 3; + } else { + ircbot->flood_protection_enabled = false; + } + libconfig->setting_lookup_bool(settings, "allow_user_channel_creation", &allow_user_channel_creation); if( allow_user_channel_creation ) diff --git a/src/map/chat.c b/src/map/chat.c index d60b9bece..df48e1f2c 100644 --- a/src/map/chat.c +++ b/src/map/chat.c @@ -97,7 +97,7 @@ bool chat_createpcchat(struct map_session_data* sd, const char* title, const cha nullpo_ret(title); nullpo_ret(pass); - if( sd->chatID ) + if (sd->chat_id != 0) return false; //Prevent people abusing the chat system by creating multiple chats, as pointed out by End of Exam. [Skotlex] if( sd->state.vending || sd->state.buyingstore ) @@ -142,8 +142,10 @@ bool chat_joinchat(struct map_session_data* sd, int chatid, const char* pass) { nullpo_ret(pass); cd = map->id2cd(chatid); - if( cd == NULL || cd->bl.type != BL_CHAT || cd->bl.m != sd->bl.m || sd->state.vending || sd->state.buyingstore || sd->chatID || ((cd->owner->type == BL_NPC) ? cd->users+1 : cd->users) >= cd->limit ) - { + if (cd == NULL || cd->bl.type != BL_CHAT || cd->bl.m != sd->bl.m + || sd->state.vending || sd->state.buyingstore || sd->chat_id != 0 + || ((cd->owner->type == BL_NPC) ? cd->users+1 : cd->users) >= cd->limit + ) { clif->joinchatfail(sd,0); // room full return false; } @@ -204,8 +206,8 @@ int chat_leavechat(struct map_session_data* sd, bool kicked) { nullpo_retr(0, sd); - cd = map->id2cd(sd->chatID); - if( cd == NULL ) { + cd = map->id2cd(sd->chat_id); + if (cd == NULL) { pc_setchatid(sd, 0); return 0; } @@ -279,7 +281,7 @@ bool chat_changechatowner(struct map_session_data* sd, const char* nextownername nullpo_ret(sd); nullpo_ret(nextownername); - cd = map->id2cd(sd->chatID); + cd = map->id2cd(sd->chat_id); if (cd == NULL || &sd->bl != cd->owner) return false; @@ -324,7 +326,7 @@ bool chat_changechatstatus(struct map_session_data* sd, const char* title, const nullpo_ret(title); nullpo_ret(pass); - cd = map->id2cd(sd->chatID); + cd = map->id2cd(sd->chat_id); if (cd == NULL || &sd->bl != cd->owner) return false; @@ -352,7 +354,7 @@ bool chat_kickchat(struct map_session_data* sd, const char* kickusername) { nullpo_ret(sd); nullpo_ret(kickusername); - cd = map->id2cd(sd->chatID); + cd = map->id2cd(sd->chat_id); if (cd == NULL || &sd->bl != cd->owner) return false; diff --git a/src/map/chrif.c b/src/map/chrif.c index 52af1137e..51e8e5143 100644 --- a/src/map/chrif.c +++ b/src/map/chrif.c @@ -236,11 +236,13 @@ void chrif_setpasswd(char *pwd) { // security check, prints warning if using default password void chrif_checkdefaultlogin(void) { +#ifndef BUILDBOT if (strcmp(chrif->userid, "s1")==0 && strcmp(chrif->passwd, "p1")==0) { ShowWarning("Using the default user/password s1/p1 is NOT RECOMMENDED.\n"); ShowNotice("Please edit your 'login' table to create a proper inter-server user/password (gender 'S')\n"); ShowNotice("and then edit your user/password in conf/map-server.conf (or conf/import/map_conf.txt)\n"); } +#endif } // sets char-server's ip address diff --git a/src/map/clif.c b/src/map/clif.c index e1b4be8f4..0f6e985fd 100644 --- a/src/map/clif.c +++ b/src/map/clif.c @@ -190,7 +190,7 @@ static inline void RFIFOPOS2(int fd, unsigned short pos, short* x0, short* y0, s #endif // 0 //To identify disguised characters. -static inline bool disguised(struct block_list* bl) +bool clif_isdisguised(struct block_list* bl) { struct map_session_data *sd = BL_CAST(BL_PC, bl); if (sd == NULL || sd->disguise == -1) @@ -265,24 +265,50 @@ uint32 clif_refresh_ip(void) return 0; } +unsigned char clif_bl_type(struct block_list *bl) +{ #if PACKETVER >= 20071106 -static inline unsigned char clif_bl_type(struct block_list *bl) { - nullpo_retr(0x1, bl); + struct view_data *vd; + nullpo_retr(CLUT_NPC, bl); + switch (bl->type) { - case BL_PC: return (disguised(bl) && !pc->db_checkid(status->get_viewdata(bl)->class_))? 0x1:0x0; //PC_TYPE - case BL_ITEM: return 0x2; //ITEM_TYPE - case BL_SKILL: return 0x3; //SKILL_TYPE - case BL_CHAT: return 0x4; //UNKNOWN_TYPE - case BL_MOB: return pc->db_checkid(status->get_viewdata(bl)->class_)?0x0:0x5; //NPC_MOB_TYPE - case BL_NPC: return pc->db_checkid(status->get_viewdata(bl)->class_)?0x0:0x6; //NPC_EVT_TYPE - case BL_PET: return pc->db_checkid(status->get_viewdata(bl)->class_)?0x0:0x7; //NPC_PET_TYPE - case BL_HOM: return 0x8; //NPC_HOM_TYPE - case BL_MER: return 0x9; //NPC_MERSOL_TYPE - case BL_ELEM: return 0xa; //NPC_ELEMENTAL_TYPE - default: return 0x1; //NPC_TYPE + case BL_PC: + vd = status->get_viewdata(bl); + nullpo_retr(CLUT_NPC, vd); + + if (clif->isdisguised(bl) && !pc->db_checkid(vd->class_)) + return CLUT_NPC; + return CLUT_PC; + case BL_ITEM: + return CLUT_ITEM; + case BL_SKILL: + return CLUT_SKILL; + case BL_CHAT: + return CLUT_UNKNOWN; + case BL_MOB: + vd = status->get_viewdata(bl); + nullpo_retr(CLUT_NPC, vd); + return pc->db_checkid(vd->class_) ? CLUT_PC : CLUT_MOB; + case BL_NPC: + vd = status->get_viewdata(bl); + nullpo_retr(CLUT_NPC, vd); + return pc->db_checkid(vd->class_) ? CLUT_PC : CLUT_EVENT; + case BL_PET: + vd = status->get_viewdata(bl); + nullpo_retr(CLUT_NPC, vd); + return pc->db_checkid(vd->class_) ? CLUT_PC : CLUT_PET; + case BL_HOM: + return CLUT_HOMNUCLUS; + case BL_MER: + return CLUT_MERCNARY; + case BL_ELEM: + return CLUT_ELEMENTAL; + default: + return CLUT_NPC; } -} #endif + return CLUT_UNKNOWN; +} /*========================================== * sub process of clif_send @@ -319,17 +345,17 @@ int clif_send_sub(struct block_list *bl, va_list ap) { return 0; break; case AREA_WOC: - if (sd->chatID || bl == src_bl) + if (sd->chat_id != 0 || bl == src_bl) return 0; break; case AREA_WOSC: { if (src_bl->type == BL_PC) { const struct map_session_data *ssd = BL_UCCAST(BL_PC, src_bl); - if (ssd != NULL && sd->chatID != 0 && (sd->chatID == ssd->chatID)) + if (ssd != NULL && sd->chat_id != 0 && (sd->chat_id == ssd->chat_id)) return 0; } else if (src_bl->type == BL_NPC) { const struct npc_data *nd = BL_UCCAST(BL_NPC, src_bl); - if (nd != NULL && sd->chatID != 0 && (sd->chatID == nd->chat_id)) + if (nd != NULL && sd->chat_id != 0 && (sd->chat_id == nd->chat_id)) return 0; } } @@ -435,7 +461,7 @@ bool clif_send(const void* buf, int len, struct block_list* bl, enum send_target { const struct chat_data *cd = NULL; if (sd != NULL) { - cd = map->id2cd(sd->chatID); + cd = map->id2cd(sd->chat_id); } else { cd = BL_CCAST(BL_CHAT, bl); } @@ -823,7 +849,7 @@ void clif_clearunit_area(struct block_list* bl, clr_type type) clif->send(buf, packet_len(0x80), bl, type == CLR_DEAD ? AREA : AREA_WOS); - if(disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; clif->send(buf, packet_len(0x80), bl, SELF); } @@ -928,7 +954,7 @@ void clif_set_unit_idle2(struct block_list* bl, struct map_session_data *tsd, en p.PacketType = idle_unit2Type; #if PACKETVER >= 20071106 - p.objecttype = clif_bl_type(bl); + p.objecttype = clif->bl_type(bl); #endif p.GID = bl->id; p.speed = status->get_speed(bl); @@ -990,7 +1016,7 @@ void clif_set_unit_idle(struct block_list* bl, struct map_session_data *tsd, enu p.PacketType = idle_unitType; #if PACKETVER >= 20091103 p.PacketLength = sizeof(p); - p.objecttype = clif_bl_type(bl); + p.objecttype = clif->bl_type(bl); #endif #if PACKETVER >= 20131223 p.AID = bl->id; @@ -1054,7 +1080,7 @@ void clif_set_unit_idle(struct block_list* bl, struct map_session_data *tsd, enu clif->send(&p,sizeof(p),tsd?&tsd->bl:bl,target); - if( disguised(bl) ) { + if (clif->isdisguised(bl)) { #if PACKETVER >= 20091103 p.objecttype = pc->db_checkid(status->get_viewdata(bl)->class_) ? 0x0 : 0x5; //PC_TYPE : NPC_MOB_TYPE p.GID = -bl->id; @@ -1079,7 +1105,7 @@ void clif_spawn_unit2(struct block_list* bl, enum send_target target) { p.PacketType = spawn_unit2Type; #if PACKETVER >= 20071106 - p.objecttype = clif_bl_type(bl); + p.objecttype = clif->bl_type(bl); #endif p.GID = bl->id; p.speed = status->get_speed(bl); @@ -1132,7 +1158,7 @@ void clif_spawn_unit(struct block_list* bl, enum send_target target) { p.PacketType = spawn_unitType; #if PACKETVER >= 20091103 p.PacketLength = sizeof(p); - p.objecttype = clif_bl_type(bl); + p.objecttype = clif->bl_type(bl); #endif #if PACKETVER >= 20131223 p.AID = bl->id; @@ -1192,7 +1218,7 @@ void clif_spawn_unit(struct block_list* bl, enum send_target target) { p.body = vd->body_style; safestrncpy(p.name, clif->get_bl_name(bl), NAME_LENGTH); #endif - if( disguised(bl) ) { + if (clif->isdisguised(bl)) { nullpo_retv(sd); if( sd->status.class_ != sd->disguise ) clif->send(&p,sizeof(p),bl,target); @@ -1228,7 +1254,7 @@ void clif_set_unit_walking(struct block_list* bl, struct map_session_data *tsd, p.PacketLength = sizeof(p); #endif #if PACKETVER >= 20071106 - p.objecttype = clif_bl_type(bl); + p.objecttype = clif->bl_type(bl); #endif #if PACKETVER >= 20131223 p.AID = bl->id; @@ -1287,7 +1313,7 @@ void clif_set_unit_walking(struct block_list* bl, struct map_session_data *tsd, clif->send(&p,sizeof(p),tsd?&tsd->bl:bl,target); - if( disguised(bl) ) { + if (clif->isdisguised(bl)) { #if PACKETVER >= 20091103 p.objecttype = pc->db_checkid(status->get_viewdata(bl)->class_) ? 0x0 : 0x5; //PC_TYPE : NPC_MOB_TYPE p.GID = -bl->id; @@ -1756,7 +1782,7 @@ void clif_move(struct unit_data *ud) clif->send(buf, packet_len(0x86), bl, AREA_WOS); - if (disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf,2)=-bl->id; clif->send(buf, packet_len(0x86), bl, SELF); } @@ -1849,7 +1875,7 @@ void clif_fixpos(struct block_list *bl) { WBUFW(buf,8) = bl->y; clif->send(buf, packet_len(0x88), bl, AREA); - if( disguised(bl) ) { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; clif->send(buf, packet_len(0x88), bl, SELF); } @@ -1957,21 +1983,38 @@ void clif_selllist(struct map_session_data *sd) /// - set npcid of dialog window (0 by default) /// - if set to clear on next mes, clear contents /// - append this text -void clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) { - int fd = sd->fd; - size_t slen; +void clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) +{ + int fd, slen; +#ifdef SCRIPT_MES_STRIP_LINEBREAK + char *stripmes = NULL; + int i; +#endif nullpo_retv(sd); nullpo_retv(mes); - slen = strlen(mes) + 9; + + fd = sd->fd; + slen = (int)strlen(mes) + 9; + Assert_retv(slen <= INT16_MAX); sd->state.dialog = 1; WFIFOHEAD(fd, slen); - WFIFOW(fd,0)=0xb4; - WFIFOW(fd,2)=slen; - WFIFOL(fd,4)=npcid; + WFIFOW(fd,0) = 0xb4; + WFIFOW(fd,2) = slen; + WFIFOL(fd,4) = npcid; +#ifdef SCRIPT_MES_STRIP_LINEBREAK + stripmes = aStrdup(mes); + for (i = 0; stripmes[i] != '\0'; ++i) { + if (stripmes[i] == '\r') + stripmes[i] = ' '; + } + memcpy(WFIFOP(fd,8), stripmes, slen-8); + aFree(stripmes); +#else // ! SCRIPT_MES_STRIP_LINEBREAK memcpy(WFIFOP(fd,8), mes, slen-8); +#endif // SCRIPT_MES_STRIP_LINEBREAK WFIFOSET(fd,WFIFOW(fd,2)); } @@ -2072,24 +2115,27 @@ void clif_sendfakenpc(struct map_session_data *sd, int npcid) { /// WARNING: the 'cancel' button closes other windows besides the dialog window and the menu window. /// Which suggests their have intertwined behavior. (probably the mouse targeting) /// TODO investigate behavior of other windows [FlavioJS] -void clif_scriptmenu(struct map_session_data* sd, int npcid, const char* mes) { - int fd; - size_t slen; +void clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) +{ + int fd, slen; struct block_list *bl = NULL; nullpo_retv(sd); nullpo_retv(mes); + fd = sd->fd; - slen = strlen(mes) + 9; + slen = (int)strlen(mes) + 9; + Assert_retv(slen <= INT16_MAX); + if (!sd->state.using_fake_npc && (npcid == npc->fake_nd->bl.id || ((bl = map->id2bl(npcid)) != NULL && (bl->m!=sd->bl.m || bl->x<sd->bl.x-AREA_SIZE-1 || bl->x>sd->bl.x+AREA_SIZE+1 || bl->y<sd->bl.y-AREA_SIZE-1 || bl->y>sd->bl.y+AREA_SIZE+1)))) clif->sendfakenpc(sd, npcid); WFIFOHEAD(fd, slen); - WFIFOW(fd,0)=0xb7; - WFIFOW(fd,2)=slen; - WFIFOL(fd,4)=npcid; + WFIFOW(fd,0) = 0xb7; + WFIFOW(fd,2) = slen; + WFIFOL(fd,4) = npcid; memcpy(WFIFOP(fd,8), mes, slen-8); WFIFOSET(fd,WFIFOW(fd,2)); } @@ -2359,7 +2405,7 @@ void clif_additem(struct map_session_data *sd, int n, int amount, int fail) { p.nameid = sd->status.inventory[n].nameid; p.IsIdentified = sd->status.inventory[n].identify ? 1 : 0; - p.IsDamaged = sd->status.inventory[n].attribute ? 1 : 0; + p.IsDamaged = (sd->status.inventory[n].attribute & ATTR_BROKEN) != 0 ? 1 : 0; p.refiningLevel =sd->status.inventory[n].refine; clif->addcards2(&p.slot.card[0], &sd->status.inventory[n]); p.location = pc->equippoint(sd,n); @@ -2474,7 +2520,7 @@ void clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, struct p->location = eqp_pos; p->WearState = i->equip; #if PACKETVER < 20120925 - p->IsDamaged = i->attribute ? 1 : 0; + p->IsDamaged = (i->attribute & ATTR_BROKEN) != 0 ? 1 : 0; #endif p->RefiningLevel = i->refine; @@ -2494,7 +2540,7 @@ void clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, struct #if PACKETVER >= 20120925 p->Flag.IsIdentified = i->identify ? 1 : 0; - p->Flag.IsDamaged = i->attribute ? 1 : 0; + p->Flag.IsDamaged = (i->attribute & ATTR_BROKEN) != 0 ? 1 : 0; p->Flag.PlaceETCTab = i->favorite ? 1 : 0; p->Flag.SpareBits = 0; #endif @@ -3192,7 +3238,7 @@ void clif_changelook(struct block_list *bl,int type,int val) } // prevent leaking the presence of GM-hidden objects - if( sc && sc->option&OPTION_INVISIBLE && !disguised(bl) ) + if (sc && sc->option&OPTION_INVISIBLE && !clif->isdisguised(bl)) target = SELF; #if PACKETVER < 4 clif->sendlook(bl, bl->id, type, val, 0, target); @@ -3203,11 +3249,12 @@ void clif_changelook(struct block_list *bl,int type,int val) val = vd->weapon; val2 = vd->shield; } - if( disguised(bl) ) { + if (clif->isdisguised(bl)) { clif->sendlook(bl, bl->id, type, val, val2, AREA_WOS); clif->sendlook(bl, -bl->id, type, val, val2, SELF); - } else + } else { clif->sendlook(bl, bl->id, type, val, val2, target); + } #endif } @@ -3488,15 +3535,16 @@ void clif_changeoption(struct block_list* bl) WBUFW(buf,8) = (sc) ? sc->opt2 : 0; WBUFL(buf,10) = (sc != NULL) ? sc->option : ((bl->type == BL_NPC) ? BL_UCCAST(BL_NPC, bl)->option : 0); WBUFB(buf,14) = (sd)? sd->status.karma : 0; - if(disguised(bl)) { + if (clif->isdisguised(bl)) { clif->send(buf,packet_len(0x229),bl,AREA_WOS); WBUFL(buf,2) = -bl->id; clif->send(buf,packet_len(0x229),bl,SELF); WBUFL(buf,2) = bl->id; WBUFL(buf,10) = OPTION_INVISIBLE; clif->send(buf,packet_len(0x229),bl,SELF); - } else + } else { clif->send(buf,packet_len(0x229),bl,AREA); + } #else WBUFW(buf,0) = 0x119; WBUFL(buf,2) = bl->id; @@ -3504,15 +3552,16 @@ void clif_changeoption(struct block_list* bl) WBUFW(buf,8) = (sc) ? sc->opt2 : 0; WBUFL(buf,10) = (sc != NULL) ? sc->option : ((bl->type == BL_NPC) ? BL_UCCAST(BL_NPC, bl)->option : 0); WBUFB(buf,12) = (sd)? sd->status.karma : 0; - if(disguised(bl)) { + if (clif->isdisguised(bl)) { clif->send(buf,packet_len(0x119),bl,AREA_WOS); WBUFL(buf,2) = -bl->id; clif->send(buf,packet_len(0x119),bl,SELF); WBUFL(buf,2) = bl->id; WBUFW(buf,10) = OPTION_INVISIBLE; clif->send(buf,packet_len(0x119),bl,SELF); - } else + } else { clif->send(buf,packet_len(0x119),bl,AREA); + } #endif } @@ -3530,15 +3579,16 @@ void clif_changeoption2(struct block_list* bl) { WBUFL(buf,6) = (sc != NULL) ? sc->option : ((bl->type == BL_NPC) ? BL_UCCAST(BL_NPC, bl)->option : 0); WBUFL(buf,10) = clif_setlevel(bl); WBUFL(buf,14) = (sc) ? sc->opt3 : 0; - if(disguised(bl)) { + if (clif->isdisguised(bl)) { clif->send(buf,packet_len(0x28a),bl,AREA_WOS); WBUFL(buf,2) = -bl->id; clif->send(buf,packet_len(0x28a),bl,SELF); WBUFL(buf,2) = bl->id; WBUFL(buf,6) = OPTION_INVISIBLE; clif->send(buf,packet_len(0x28a),bl,SELF); - } else + } else { clif->send(buf,packet_len(0x28a),bl,AREA); + } } /// Notifies the client about the result of an item use request. @@ -3610,26 +3660,29 @@ void clif_createchat(struct map_session_data* sd, int flag) /// 1 = public /// 2 = arena (npc waiting room) /// 3 = PK zone (non-clickable) -void clif_dispchat(struct chat_data* cd, int fd) +void clif_dispchat(struct chat_data *cd, int fd) { unsigned char buf[128]; uint8 type; + int len; - if( cd == NULL || cd->owner == NULL ) + if (cd == NULL || cd->owner == NULL) return; type = (cd->owner->type == BL_PC ) ? (cd->pub) ? 1 : 0 : (cd->owner->type == BL_NPC) ? (cd->limit) ? 2 : 3 : 1; + len = (int)strlen(cd->title); + Assert_retv(len <= INT16_MAX - 17); WBUFW(buf, 0) = 0xd7; - WBUFW(buf, 2) = 17 + strlen(cd->title); + WBUFW(buf, 2) = 17 + len; WBUFL(buf, 4) = cd->owner->id; WBUFL(buf, 8) = cd->bl.id; WBUFW(buf,12) = cd->limit; WBUFW(buf,14) = (cd->owner->type == BL_NPC) ? cd->users+1 : cd->users; WBUFB(buf,16) = type; - memcpy(WBUFP(buf,17), cd->title, strlen(cd->title)); // not zero-terminated + memcpy(WBUFP(buf,17), cd->title, len); // not zero-terminated if( fd ) { WFIFOHEAD(fd,WBUFW(buf,2)); @@ -3647,10 +3700,11 @@ void clif_dispchat(struct chat_data* cd, int fd) /// 1 = public /// 2 = arena (npc waiting room) /// 3 = PK zone (non-clickable) -void clif_changechatstatus(struct chat_data* cd) +void clif_changechatstatus(struct chat_data *cd) { unsigned char buf[128]; uint8 type; + int len; if( cd == NULL || cd->usersd[0] == NULL ) return; @@ -3658,15 +3712,17 @@ void clif_changechatstatus(struct chat_data* cd) type = (cd->owner->type == BL_PC ) ? (cd->pub) ? 1 : 0 : (cd->owner->type == BL_NPC) ? (cd->limit) ? 2 : 3 : 1; + len = (int)strlen(cd->title); + Assert_retv(len <= INT16_MAX - 17); WBUFW(buf, 0) = 0xdf; - WBUFW(buf, 2) = 17 + strlen(cd->title); + WBUFW(buf, 2) = 17 + len; WBUFL(buf, 4) = cd->owner->id; WBUFL(buf, 8) = cd->bl.id; WBUFW(buf,12) = cd->limit; WBUFW(buf,14) = (cd->owner->type == BL_NPC) ? cd->users+1 : cd->users; WBUFB(buf,16) = type; - memcpy(WBUFP(buf,17), cd->title, strlen(cd->title)); // not zero-terminated + memcpy(WBUFP(buf,17), cd->title, len); // not zero-terminated clif->send(buf,WBUFW(buf,2),cd->owner,CHAT); } @@ -4115,8 +4171,8 @@ void clif_getareachar_pc(struct map_session_data* sd,struct map_session_data* ds nullpo_retv(sd); nullpo_retv(dstsd); - if( dstsd->chatID ) { - struct chat_data *cd = map->id2cd(dstsd->chatID); + if (dstsd->chat_id != 0) { + struct chat_data *cd = map->id2cd(dstsd->chat_id); if (cd != NULL && cd->usersd[0] == dstsd) clif->dispchat(cd,sd->fd); } else if( dstsd->state.vending ) @@ -4320,16 +4376,17 @@ int clif_damage(struct block_list* src, struct block_list* dst, int sdelay, int p.is_sp_damaged = 0; // TODO: IsSPDamage - Displays blue digits. #endif - if(disguised(dst)) { + if (clif->isdisguised(dst)) { clif->send(&p,sizeof(p),dst,AREA_WOS); p.targetGID = -dst->id; clif->send(&p,sizeof(p),dst,SELF); - } else + } else { clif->send(&p,sizeof(p),dst,AREA); + } - if(disguised(src)) { + if (clif->isdisguised(src)) { p.GID = -src->id; - if (disguised(dst)) + if (clif->isdisguised(dst)) p.targetGID = dst->id; if(damage > 0) p.damage = -1; @@ -4378,7 +4435,7 @@ void clif_sitting(struct block_list* bl) WBUFB(buf,26) = 2; clif->send(buf, packet_len(0x8a), bl, AREA); - if(disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf, 2) = - bl->id; clif->send(buf, packet_len(0x8a), bl, SELF); } @@ -4397,7 +4454,7 @@ void clif_standing(struct block_list* bl) WBUFB(buf,26) = 3; clif->send(buf, packet_len(0x8a), bl, AREA); - if(disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf, 2) = - bl->id; clif->send(buf, packet_len(0x8a), bl, SELF); } @@ -4618,9 +4675,9 @@ int clif_outsight(struct block_list *bl,va_list ap) case BL_PC: if (sd->vd.class_ != INVISIBLE_CLASS) clif->clearunit_single(bl->id,CLR_OUTSIGHT,tsd->fd); - if (sd->chatID) { - struct chat_data *cd = map->id2cd(sd->chatID); - if(cd->usersd[0]==sd) + if (sd->chat_id != 0) { + struct chat_data *cd = map->id2cd(sd->chat_id); + if (cd != NULL && cd->usersd[0] == sd) clif->dispchat(cd,tsd->fd); } if( sd->state.vending ) @@ -4895,12 +4952,13 @@ void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x, WBUFB(buf,24) = 0; // isDisposable #endif - if (disguised(bl)) { + if (clif->isdisguised(bl)) { clif->send(buf,packet_len(cmd), bl, AREA_WOS); WBUFL(buf,2) = -src_id; clif->send(buf,packet_len(cmd), bl, SELF); - } else + } else { clif->send(buf,packet_len(cmd), bl, AREA); + } } /// Notifies clients in area, that an object canceled casting (ZC_DISPEL). @@ -5030,16 +5088,17 @@ int clif_skill_damage(struct block_list *src, struct block_list *dst, int64 tick WBUFW(buf, 26) = skill_lv; WBUFW(buf, 28) = div; WBUFB(buf, 30) = type; - if (disguised(dst)) { + if (clif->isdisguised(dst)) { clif->send(buf, packet_len(0x114), dst, AREA_WOS); WBUFL(buf, 8) = -dst->id; clif->send(buf, packet_len(0x114), dst, SELF); - } else + } else { clif->send(buf, packet_len(0x114), dst, AREA); + } - if (disguised(src)) { + if (clif->isdisguised(src)) { WBUFL(buf, 4) = -src->id; - if (disguised(dst)) + if (clif->isdisguised(dst)) WBUFL(buf, 8) = dst->id; if (damage > 0) WBUFW(buf, 24) = -1; @@ -5069,16 +5128,17 @@ int clif_skill_damage(struct block_list *src, struct block_list *dst, int64 tick #else WBUFB(buf, 32) = (type == BDT_SKILL) ? BDT_MULTIHIT : type; #endif - if (disguised(dst)) { + if (clif->isdisguised(dst)) { clif->send(buf, packet_len(0x1de), dst, AREA_WOS); WBUFL(buf,8)=-dst->id; clif->send(buf, packet_len(0x1de), dst, SELF); - } else + } else { clif->send(buf, packet_len(0x1de), dst, AREA); + } - if (disguised(src)) { + if (clif->isdisguised(src)) { WBUFL(buf, 4) = -src->id; - if (disguised(dst)) + if (clif->isdisguised(dst)) WBUFL(buf, 8) = dst->id; if (damage > 0) WBUFL(buf, 24) = -1; @@ -5127,15 +5187,15 @@ int clif_skill_damage2(struct block_list *src, struct block_list *dst, int64 tic WBUFW(buf,32)=div; WBUFB(buf,34)=type; clif->send(buf,packet_len(0x115),src,AREA); - if(disguised(src)) { + if (clif->isdisguised(src)) { WBUFL(buf,4)=-src->id; if(damage > 0) WBUFW(buf,28)=-1; clif->send(buf,packet_len(0x115),src,SELF); } - if (disguised(dst)) { + if (clif->isdisguised(dst)) { WBUFL(buf,8)=-dst->id; - if (disguised(src)) + if (clif->isdisguised(src)) WBUFL(buf,4)=src->id; else if(damage > 0) WBUFW(buf,28)=-1; @@ -5162,16 +5222,16 @@ int clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 ski WBUFL(buf,10)=src?src->id:0; WBUFB(buf,14)=fail; - if (disguised(dst)) { + if (clif->isdisguised(dst)) { clif->send(buf,packet_len(0x11a),dst,AREA_WOS); WBUFL(buf,6)=-dst->id; clif->send(buf,packet_len(0x11a),dst,SELF); } else clif->send(buf,packet_len(0x11a),dst,AREA); - if(src && disguised(src)) { + if (src && clif->isdisguised(src)) { WBUFL(buf,10)=-src->id; - if (disguised(dst)) + if (clif->isdisguised(dst)) WBUFL(buf,6)=dst->id; clif->send(buf,packet_len(0x11a),src,SELF); } @@ -5193,12 +5253,13 @@ void clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, int WBUFW(buf,10)=x; WBUFW(buf,12)=y; WBUFL(buf,14)=(uint32)tick; - if(disguised(src)) { + if (clif->isdisguised(src)) { clif->send(buf,packet_len(0x117),src,AREA_WOS); WBUFL(buf,4)=-src->id; clif->send(buf,packet_len(0x117),src,SELF); - } else + } else { clif->send(buf,packet_len(0x117),src,AREA); + } } /// Presents a list of available warp destinations (ZC_WARPLIST). @@ -5478,23 +5539,24 @@ void clif_status_change(struct block_list *bl,int type,int flag,int tick,int val /// Send message (modified by [Yor]) (ZC_NOTIFY_PLAYERCHAT). /// 008e <packet len>.W <message>.?B -void clif_displaymessage(const int fd, const char* mes) { +void clif_displaymessage(const int fd, const char *mes) +{ nullpo_retv(mes); - if( map->cpsd_active && fd == 0 ) { + if (map->cpsd_active && fd == 0) { ShowInfo("HCP: %s\n",mes); - } else if ( fd > 0 ) { + } else if (fd > 0) { #if PACKETVER == 20141022 /** for some reason game client crashes depending on message pattern (only for this packet) **/ /** so we redirect to ZC_NPC_CHAT **/ clif->messagecolor_self(fd, COLOR_DEFAULT, mes); #else - size_t len; + int len = (int)strnlen(mes, 255); - if ( ( len = strnlen(mes, 255) ) > 0 ) { // don't send a void message (it's not displaying on the client chat). @help can send void line. + if (len > 0) { // don't send a void message (it's not displaying on the client chat). @help can send void line. WFIFOHEAD(fd, 5 + len); WFIFOW(fd,0) = 0x8e; - WFIFOW(fd,2) = 5 + len; // 4 + len + NULL terminate + WFIFOW(fd,2) = 5 + len; // 4 + len + NUL terminate safestrncpy(WFIFOP(fd,4), mes, len + 1); WFIFOSET(fd, 5 + len); } @@ -5516,7 +5578,7 @@ void clif_displaymessage2(const int fd, const char* mes) { line = strtok(message, "\n"); while(line != NULL) { // Limit message to 255+1 characters (otherwise it causes a buffer overflow in the client) - size_t len = strnlen(line, 255); + int len = (int)strnlen(line, 255); if (len > 0) { // don't send a void message (it's not displaying on the client chat). @help can send void line. if( map->cpsd_active && fd == 0 ) { @@ -5570,7 +5632,7 @@ void clif_displaymessage_sprintf(const int fd, const char *mes, ...) { } /// Send broadcast message in yellow or blue without font formatting (ZC_BROADCAST). /// 009a <packet len>.W <message>.?B -void clif_broadcast(struct block_list *bl, const char *mes, size_t len, int type, enum send_target target) +void clif_broadcast(struct block_list *bl, const char *mes, int len, int type, enum send_target target) { int lp = (type&BC_COLOR_MASK) ? 4 : 0; unsigned char *buf = NULL; @@ -5594,38 +5656,38 @@ void clif_broadcast(struct block_list *bl, const char *mes, size_t len, int type * Displays a message on a 'bl' to all it's nearby clients * Used by npc_globalmessage *------------------------------------------*/ -void clif_GlobalMessage(struct block_list* bl, const char* message) { +void clif_GlobalMessage(struct block_list *bl, const char *message) +{ char buf[256]; - size_t len; + int len; nullpo_retv(bl); - if(!message) + if (message == NULL) return; - len = strlen(message)+1; + len = (int)strlen(message)+1; - if (len > sizeof(buf)-8) { - ShowWarning("clif_GlobalMessage: Truncating too long message '%s' (len=%"PRIuS").\n", message, len); - len = sizeof(buf)-8; + if (len > (int)sizeof(buf)-8) { + ShowWarning("clif_GlobalMessage: Truncating too long message '%s' (len=%d).\n", message, len); + len = (int)sizeof(buf)-8; } - WBUFW(buf,0)=0x8d; - WBUFW(buf,2)=len+8; - WBUFL(buf,4)=bl->id; + WBUFW(buf,0) = 0x8d; + WBUFW(buf,2) = len+8; + WBUFL(buf,4) = bl->id; safestrncpy(WBUFP(buf,8),message,len); - clif->send((unsigned char *) buf,WBUFW(buf,2),bl,ALL_CLIENT); - + clif->send(buf,WBUFW(buf,2),bl,ALL_CLIENT); } /// Send broadcast message with font formatting (ZC_BROADCAST2). /// 01c3 <packet len>.W <fontColor>.L <fontType>.W <fontSize>.W <fontAlign>.W <fontY>.W <message>.?B -void clif_broadcast2(struct block_list* bl, const char* mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) +void clif_broadcast2(struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) { unsigned char *buf; nullpo_retv(mes); - buf = (unsigned char*)aMalloc((16 + len)*sizeof(unsigned char)); + buf = aMalloc((16 + len)*sizeof(unsigned char)); WBUFW(buf,0) = 0x1c3; WBUFW(buf,2) = len + 16; WBUFL(buf,4) = fontColor; @@ -5669,7 +5731,7 @@ void clif_resurrection(struct block_list *bl,int type) WBUFW(buf,6)=0; clif->send(buf,packet_len(0x148),bl, type == 1 ? AREA : AREA_WOS); - if (disguised(bl)) { + if (clif->isdisguised(bl)) { struct map_session_data *sd = BL_UCAST(BL_PC, bl); if (sd->fontcolor) { WBUFL(buf,2)=-bl->id; @@ -5793,7 +5855,7 @@ void clif_upgrademessage(int fd, int result, int item_id) /// Whisper is transmitted to the destination player (ZC_WHISPER). /// 0097 <packet len>.W <nick>.24B <message>.?B /// 0097 <packet len>.W <nick>.24B <isAdmin>.L <message>.?B (PACKETVER >= 20091104) -void clif_wis_message(int fd, const char *nick, const char *mes, size_t mes_len) +void clif_wis_message(int fd, const char *nick, const char *mes, int mes_len) { #if PACKETVER >= 20091104 struct map_session_data *ssd = NULL; @@ -5802,21 +5864,21 @@ void clif_wis_message(int fd, const char *nick, const char *mes, size_t mes_len) nullpo_retv(mes); #if PACKETVER < 20091104 - WFIFOHEAD(fd, mes_len + NAME_LENGTH + 4); + WFIFOHEAD(fd, mes_len + NAME_LENGTH + 5); WFIFOW(fd,0) = 0x97; - WFIFOW(fd,2) = mes_len + NAME_LENGTH + 4; + WFIFOW(fd,2) = mes_len + NAME_LENGTH + 5; safestrncpy(WFIFOP(fd,4), nick, NAME_LENGTH); - safestrncpy(WFIFOP(fd,28), mes, mes_len); + safestrncpy(WFIFOP(fd,28), mes, mes_len + 1); WFIFOSET(fd,WFIFOW(fd,2)); #else ssd = map->nick2sd(nick); - WFIFOHEAD(fd, mes_len + NAME_LENGTH + 8); + WFIFOHEAD(fd, mes_len + NAME_LENGTH + 9); WFIFOW(fd,0) = 0x97; - WFIFOW(fd,2) = mes_len + NAME_LENGTH + 8; + WFIFOW(fd,2) = mes_len + NAME_LENGTH + 9; safestrncpy(WFIFOP(fd,4), nick, NAME_LENGTH); WFIFOL(fd,28) = (ssd && pc_get_group_level(ssd) == 99) ? 1 : 0; // isAdmin; if nonzero, also displays text above char - safestrncpy(WFIFOP(fd,32), mes, mes_len); + safestrncpy(WFIFOP(fd,32), mes, mes_len + 1); WFIFOSET(fd,WFIFOW(fd,2)); #endif } @@ -5966,7 +6028,7 @@ void clif_item_repair_list(struct map_session_data *sd,struct map_session_data * WFIFOW(fd,0)=0x1fc; for (i = c = 0; i < MAX_INVENTORY; i++) { int nameid = dstsd->status.inventory[i].nameid; - if (nameid > 0 && dstsd->status.inventory[i].attribute != 0) { // && skill_can_repair(sd,nameid)) { + if (nameid > 0 && (dstsd->status.inventory[i].attribute & ATTR_BROKEN) != 0) { // && skill_can_repair(sd,nameid)) { WFIFOW(fd,c*13+4) = i; WFIFOW(fd,c*13+6) = nameid; WFIFOB(fd,c*13+8) = dstsd->status.inventory[i].refine; @@ -6602,7 +6664,7 @@ void clif_party_withdraw(struct party_data* p, struct map_session_data* sd, int /// Party chat message (ZC_NOTIFY_CHAT_PARTY). /// 0109 <packet len>.W <account id>.L <message>.?B -void clif_party_message(struct party_data* p, int account_id, const char* mes, int len) +void clif_party_message(struct party_data *p, int account_id, const char *mes, int len) { struct map_session_data *sd; int i; @@ -6610,22 +6672,24 @@ void clif_party_message(struct party_data* p, int account_id, const char* mes, i nullpo_retv(p); nullpo_retv(mes); - for(i=0; i < MAX_PARTY && !p->data[i].sd;i++); - if(i < MAX_PARTY){ + ARR_FIND(0, MAX_PARTY, i, p->data[i].sd != NULL); + + if (i < MAX_PARTY) { unsigned char buf[1024]; + int maxlen = (int)sizeof(buf) - 9; - if (len > sizeof(buf)-8) { - ShowWarning("clif_party_message: Truncated message '%s' (len=%d, max=%"PRIuS", party_id=%d).\n", - mes, len, sizeof(buf)-8, p->party.party_id); - len = sizeof(buf)-8; + if (len > maxlen) { + ShowWarning("clif_party_message: Truncated message '%s' (len=%d, max=%d, party_id=%d).\n", + mes, len, maxlen, p->party.party_id); + len = maxlen; } sd = p->data[i].sd; - WBUFW(buf,0)=0x109; - WBUFW(buf,2)=len+8; - WBUFL(buf,4)=account_id; - safestrncpy(WBUFP(buf,8), mes, len); - clif->send(buf,len+8,&sd->bl,PARTY); + WBUFW(buf,0) = 0x109; + WBUFW(buf,2) = len+9; + WBUFL(buf,4) = account_id; + safestrncpy(WBUFP(buf,8), mes, len+1); + clif->send(buf, len+9, &sd->bl, PARTY); } } @@ -7937,19 +8001,21 @@ void clif_marriage_proposal(int fd, struct map_session_data *sd, struct map_sess /*========================================== * Displays a message using the guild-chat colors to the specified targets. [Skotlex] *------------------------------------------*/ -void clif_disp_message(struct block_list* src, const char* mes, size_t len, enum send_target target) +void clif_disp_message(struct block_list *src, const char *mes, enum send_target target) { unsigned char buf[256]; + int len; + + nullpo_retv(mes); + nullpo_retv(src); + len = (int)strlen(mes); if (len == 0) return; - nullpo_retv(src); - nullpo_retv(mes); - - if (len > sizeof(buf)-5) { - ShowWarning("clif_disp_message: Truncated message '%s' (len=%"PRIuS", max=%"PRIuS", aid=%d).\n", mes, len, sizeof(buf)-5, src->id); - len = sizeof(buf)-5; + if (len > (int)sizeof(buf)-5) { + ShowWarning("clif_disp_message: Truncated message '%s' (len=%d, max=%"PRIuS", aid=%d).\n", mes, len, sizeof(buf)-5, src->id); + len = (int)sizeof(buf)-5; } WBUFW(buf, 0) = 0x17f; @@ -8154,7 +8220,7 @@ void clif_specialeffect(struct block_list* bl, int type, enum send_target target clif->send(buf, packet_len(0x1f3), bl, target); - if (disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; clif->send(buf, packet_len(0x1f3), bl, SELF); } @@ -8186,8 +8252,7 @@ void clif_specialeffect_value(struct block_list* bl, int effect_id, int num, sen clif->send(buf, packet_len(0x284), bl, target); - if( disguised(bl) ) - { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; clif->send(buf, packet_len(0x284), bl, SELF); } @@ -8203,10 +8268,11 @@ void clif_specialeffect_value(struct block_list* bl, int effect_id, int num, sen */ void clif_messagecolor_self(int fd, uint32 color, const char *msg) { - size_t msg_len; + int msg_len; nullpo_retv(msg); - msg_len = strlen(msg) + 1; + msg_len = (int)strlen(msg) + 1; + Assert_retv(msg_len <= INT16_MAX - 12); WFIFOHEAD(fd,msg_len + 12); WFIFOW(fd,0) = 0x2C1; @@ -8226,17 +8292,19 @@ void clif_messagecolor_self(int fd, uint32 color, const char *msg) * @param color Message color (RGB format: 0xRRGGBB) * @param msg Message text */ -void clif_messagecolor(struct block_list* bl, uint32 color, const char *msg) +void clif_messagecolor(struct block_list *bl, uint32 color, const char *msg) { - size_t msg_len = strlen(msg) + 1; + int msg_len; uint8 buf[256]; nullpo_retv(bl); nullpo_retv(msg); - if (msg_len > sizeof(buf)-12) { - ShowWarning("clif_messagecolor: Truncating too long message '%s' (len=%"PRIuS").\n", msg, msg_len); - msg_len = sizeof(buf)-12; + msg_len = (int)strlen(msg) + 1; + + if (msg_len > (int)sizeof(buf)-12) { + ShowWarning("clif_messagecolor: Truncating too long message '%s' (len=%d).\n", msg, msg_len); + msg_len = (int)sizeof(buf)-12; } WBUFW(buf,0) = 0x2C1; @@ -8316,7 +8384,7 @@ void clif_refresh(struct map_session_data *sd) clif->elemental_info(sd); map->foreachinrange(clif->getareachar,&sd->bl,AREA_SIZE,BL_ALL,sd); clif->weather_check(sd); - if( sd->chatID ) + if (sd->chat_id != 0) chat->leave(sd, false); if( sd->state.vending ) clif->openvending(sd, sd->bl.id, sd->vending); @@ -8332,7 +8400,7 @@ void clif_refresh(struct map_session_data *sd) mail->clear(sd); - if( disguised(&sd->bl) ) {/* refresh-da */ + if (clif->isdisguised(&sd->bl)) {/* refresh-da */ short disguise = sd->disguise; pc->disguise(sd, -1); pc->disguise(sd, disguise); @@ -8547,8 +8615,7 @@ void clif_slide(struct block_list *bl, int x, int y) WBUFW(buf, 8) = y; clif->send(buf, packet_len(0x1ff), bl, AREA); - if( disguised(bl) ) - { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; clif->send(buf, packet_len(0x1ff), bl, SELF); } @@ -8556,34 +8623,33 @@ void clif_slide(struct block_list *bl, int x, int y) /// Public chat message (ZC_NOTIFY_CHAT). lordalfa/Skotlex - used by @me as well /// 008d <packet len>.W <id>.L <message>.?B -void clif_disp_overhead(struct block_list *bl, const char* mes) +void clif_disp_overhead(struct block_list *bl, const char *mes) { unsigned char buf[256]; //This should be more than sufficient, the theoretical max is CHAT_SIZE + 8 (pads and extra inserted crap) - size_t len_mes; + int mes_len; nullpo_retv(bl); nullpo_retv(mes); - len_mes = strlen(mes)+1; //Account for \0 + mes_len = (int)strlen(mes)+1; //Account for \0 - if (len_mes > sizeof(buf)-8) { - ShowError("clif_disp_overhead: Message too long (length %"PRIuS")\n", len_mes); - len_mes = sizeof(buf)-8; //Trunk it to avoid problems. + if (mes_len > (int)sizeof(buf)-8) { + ShowError("clif_disp_overhead: Message too long (length %d)\n", mes_len); + mes_len = sizeof(buf)-8; //Trunk it to avoid problems. } // send message to others WBUFW(buf,0) = 0x8d; - WBUFW(buf,2) = len_mes + 8; // len of message + 8 (command+len+id) + WBUFW(buf,2) = mes_len + 8; // len of message + 8 (command+len+id) WBUFL(buf,4) = bl->id; - safestrncpy(WBUFP(buf,8), mes, len_mes); + safestrncpy(WBUFP(buf,8), mes, mes_len); clif->send(buf, WBUFW(buf,2), bl, AREA_CHAT_WOC); // send back message to the speaker - if( bl->type == BL_PC ) { + if (bl->type == BL_PC) { WBUFW(buf,0) = 0x8e; - WBUFW(buf, 2) = len_mes + 4; - safestrncpy(WBUFP(buf,4), mes, len_mes); + WBUFW(buf, 2) = mes_len + 4; + safestrncpy(WBUFP(buf,4), mes, mes_len); clif->send(buf, WBUFW(buf,2), bl, SELF); } - } /*========================== @@ -8867,105 +8933,137 @@ void clif_msgtable_skill(struct map_session_data* sd, uint16 skill_id, int msg_i WFIFOSET(fd, packet_len(0x7e6)); } -/// Validates one global/guild/party/whisper message packet and tries to recognize its components. -/// Returns true if the packet was parsed successfully. -/// Formats: 0 - <packet id>.w <packet len>.w (<name> : <message>).?B 00 -/// 1 - <packet id>.w <packet len>.w <name>.24B <message>.?B 00 -bool clif_process_message(struct map_session_data *sd, int format, const char **name_, size_t *namelen_, const char **message_, size_t *messagelen_) +/** + * Validates and processes a global/guild/party message packet. + * + * @param[in] sd The source character. + * @param[in] packet The packet data. + * @param[out] out_buf The output buffer (must be a valid buffer), that will + * be filled with "Name : Message". + * @param[in] out_buflen The size of out_buf (including the NUL terminator). + * @return a pointer to the "Message" part of out_buf. + * @retval NULL if the validation failed, the messages was a command or the + * character can't send chat messages. out_buf shan't be used. + */ +const char *clif_process_chat_message(struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen) { - const char *text, *name, *message; - unsigned int packetlen, textlen; - size_t namelen, messagelen; - int fd = sd->fd; + const char *srcname = NULL, *srcmessage = NULL, *message = NULL; + int textlen = 0, namelen = 0, messagelen = 0; - nullpo_retr(false, sd); - nullpo_retr(false, name_); - nullpo_retr(false, namelen_); - nullpo_retr(false, message_); - nullpo_retr(false, messagelen_); - - *name_ = NULL; - *namelen_ = 0; - *message_ = NULL; - *messagelen_ = 0; - - packetlen = RFIFOW(fd,2); - // basic structure checks - if (packetlen < 4 + 1) { + nullpo_ret(sd); + nullpo_ret(packet); + nullpo_ret(out_buf); + + if (packet->packet_len < 4 + 1) { // 4-byte header and at least an empty string is expected - ShowWarning("clif_process_message: Received malformed packet from player '%s' (no message data)!\n", sd->status.name); - return false; + ShowWarning("clif_process_chat_message: Received malformed packet from player '%s' (no message data)!\n", sd->status.name); + return NULL; } - text = RFIFOP(fd,4); - textlen = packetlen - 4; +#if PACKETVER >= 20151001 + // Packet doesn't include a NUL terminator + textlen = packet->packet_len - 4; +#else // PACKETVER < 20151001 + // Packet includes a NUL terminator + textlen = packet->packet_len - 4 - 1; +#endif // PACKETVER > 20151001 - // process <name> part of the packet - if( format == 0 ) - {// name and message are separated by ' : ' - // validate name - name = text; - namelen = strnlen(sd->status.name, NAME_LENGTH-1); // name length (w/o zero byte) + // name and message are separated by ' : ' + srcname = packet->message; + namelen = (int)strnlen(sd->status.name, NAME_LENGTH-1); // name length (w/o zero byte) - if( strncmp(name, sd->status.name, namelen) || // the text must start with the speaker's name - name[namelen] != ' ' || name[namelen+1] != ':' || name[namelen+2] != ' ' ) // followed by ' : ' - { - //Hacked message, or infamous "client desynchronize" issue where they pick one char while loading another. - ShowWarning("clif_process_message: Player '%s' sent a message using an incorrect name! Forcing a relog...\n", sd->status.name); - sockt->eof(fd); // Just kick them out to correct it. - return false; - } + if (strncmp(srcname, sd->status.name, namelen) != 0 // the text must start with the speaker's name + || srcname[namelen] != ' ' || srcname[namelen+1] != ':' || srcname[namelen+2] != ' ' // followed by ' : ' + ) { + //Hacked message, or infamous "client desynchronize" issue where they pick one char while loading another. + ShowWarning("clif_process_chat_message: Player '%s' sent a message using an incorrect name! Forcing a relog...\n", sd->status.name); + sockt->eof(sd->fd); // Just kick them out to correct it. + return NULL; + } - message = name + namelen + 3; - messagelen = textlen - namelen - 3; // this should be the message length (w/ zero byte included) + srcmessage = packet->message + namelen + 3; // <name> " : " <message> + messagelen = textlen - namelen - 3; + + if (messagelen >= CHAT_SIZE_MAX || textlen >= out_buflen) { + // messages mustn't be too long + // Normally you can only enter CHATBOX_SIZE-1 letters into the chat box, but Frost Joke / Dazzler's text can be longer. + // Also, the physical size of strings that use multibyte encoding can go multiple times over the chatbox capacity. + // Neither the official client nor server place any restriction on the length of the data in the packet, + // but we'll only allow reasonably long strings here. This also makes sure that they fit into the `chatlog` table. + ShowWarning("clif_process_chat_message: Player '%s' sent a message too long ('%.*s')!\n", sd->status.name, CHATBOX_SIZE-1, srcmessage); + return NULL; } - else - {// name has fixed width - if( textlen < NAME_LENGTH + 1 ) - { - ShowWarning("clif_process_message: Received malformed packet from player '%s' (packet length is incorrect)!\n", sd->status.name); - return false; - } - // validate name - name = text; - namelen = strnlen(name, NAME_LENGTH-1); // name length (w/o zero byte) + safestrncpy(out_buf, packet->message, textlen+1); // [!] packet->message is not necessarily NUL terminated + message = out_buf + namelen + 3; - if (name[namelen] != '\0') { - // only restriction is that the name must be zero-terminated - ShowWarning("clif_process_message: Player '%s' sent an unterminated name!\n", sd->status.name); - return false; - } + if (!pc->process_chat_message(sd, message)) + return NULL; + return message; +} - message = name + NAME_LENGTH; - messagelen = textlen - NAME_LENGTH; // this should be the message length (w/ zero byte included) - } +/** + * Validates and processes a whisper message packet. + * + * @param[in] sd The source character. + * @param[in] packet The packet data. + * @param[out] out_name The parsed target name buffer (must be a valid + * buffer of size NAME_LENGTH). + * @param[out] out_message The output message buffer (must be a valid buffer). + * @param[in] out_messagelen The size of out_message. + * @retval true if the validation succeeded and the message is a chat message. + * @retval false if the validation failed, the messages was a command or the + * character can't send chat messages. out_name and out_message + * shan't be used. + */ +bool clif_process_whisper_message(struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen) +{ + int namelen = 0, messagelen = 0; + + nullpo_retr(false, sd); + nullpo_retr(false, packet); + nullpo_retr(false, out_name); + nullpo_retr(false, out_message); - if (messagelen != strnlen(message, messagelen)+1) { - // the declared length must match real length - ShowWarning("clif_process_message: Received malformed packet from player '%s' (length is incorrect)!\n", sd->status.name); + if (packet->packet_len < NAME_LENGTH + 4 + 1) { + // 4-byte header and at least an empty string is expected + ShowWarning("clif_process_whisper_message: Received malformed packet from player '%s' (packet length is incorrect)!\n", sd->status.name); return false; } - // verify <message> part of the packet - if (message[messagelen-1] != '\0') { - // message must be zero-terminated - ShowWarning("clif_process_message: Player '%s' sent an unterminated message string!\n", sd->status.name); + + // validate name + namelen = (int)strnlen(packet->name, NAME_LENGTH-1); // name length (w/o zero byte) + + if (packet->name[namelen] != '\0') { + // only restriction is that the name must be zero-terminated + ShowWarning("clif_process_whisper_message: Player '%s' sent an unterminated name!\n", sd->status.name); return false; } - if (messagelen > CHAT_SIZE_MAX-1) { + +#if PACKETVER >= 20151001 + // Packet doesn't include a NUL terminator + messagelen = packet->packet_len - NAME_LENGTH - 4; +#else // PACKETVER < 20151001 + // Packet includes a NUL terminator + messagelen = packet->packet_len - NAME_LENGTH - 4 - 1; +#endif // PACKETVER > 20151001 + + if (messagelen >= CHAT_SIZE_MAX || messagelen >= out_messagelen) { // messages mustn't be too long // Normally you can only enter CHATBOX_SIZE-1 letters into the chat box, but Frost Joke / Dazzler's text can be longer. // Also, the physical size of strings that use multibyte encoding can go multiple times over the chatbox capacity. // Neither the official client nor server place any restriction on the length of the data in the packet, // but we'll only allow reasonably long strings here. This also makes sure that they fit into the `chatlog` table. - ShowWarning("clif_process_message: Player '%s' sent a message too long ('%.*s')!\n", sd->status.name, CHAT_SIZE_MAX-1, message); + ShowWarning("clif_process_whisper_message: Player '%s' sent a message too long ('%.*s')!\n", sd->status.name, CHAT_SIZE_MAX-1, packet->message); return false; } - *name_ = name; - *namelen_ = namelen; - *message_ = message; - *messagelen_ = messagelen; + safestrncpy(out_name, packet->name, namelen+1); // [!] packet->name is not NUL terminated + safestrncpy(out_message, packet->message, messagelen+1); // [!] packet->message is not necessarily NUL terminated + + if (!pc->process_chat_message(sd, out_message)) + return false; + return true; } @@ -8973,14 +9071,15 @@ void clif_channel_msg(struct channel_data *chan, struct map_session_data *sd, ch { struct DBIterator *iter; struct map_session_data *user; - unsigned short msg_len; + int msg_len; uint32 color; nullpo_retv(chan); nullpo_retv(sd); nullpo_retv(msg); iter = db_iterator(chan->users); - msg_len = strlen(msg) + 1; + msg_len = (int)strlen(msg) + 1; + Assert_retv(msg_len <= INT16_MAX - 12); color = channel->config->colors[chan->color]; WFIFOHEAD(sd->fd,msg_len + 12); @@ -9008,13 +9107,14 @@ void clif_channel_msg2(struct channel_data *chan, char *msg) struct DBIterator *iter; struct map_session_data *user; unsigned char buf[210]; - unsigned short msg_len; + int msg_len; uint32 color; nullpo_retv(chan); nullpo_retv(msg); iter = db_iterator(chan->users); - msg_len = strlen(msg) + 1; + msg_len = (int)strlen(msg) + 1; + Assert_retv(msg_len <= INT16_MAX - 12); color = channel->config->colors[chan->color]; WBUFW(buf,0) = 0x2C1; @@ -9380,7 +9480,7 @@ void clif_parse_LoadEndAck(int fd, struct map_session_data *sd) { if( map->list[sd->bl.m].flag.allowks && !map_flag_ks(sd->bl.m) ) { char output[128]; sprintf(output, "[ Kill Steal Protection Disabled. KS is allowed in this map ]"); - clif->broadcast(&sd->bl, output, strlen(output) + 1, BC_BLUE, SELF); + clif->broadcast(&sd->bl, output, (int)strlen(output) + 1, BC_BLUE, SELF); } map->iwall_get(sd); // Updates Walls Info on this Map to Client @@ -9687,7 +9787,7 @@ void clif_parse_GetCharNameRequest(int fd, struct map_session_data *sd) { // 'see people in GM hide' cheat detection #if 0 /* disabled due to false positives (network lag + request name of char that's about to hide = race condition) */ sc = status->get_sc(bl); - if (sc && sc->option&OPTION_INVISIBLE && !disguised(bl) && + if (sc && sc->option&OPTION_INVISIBLE && !clif->isdisguised(bl) && bl->type != BL_NPC && //Skip hidden NPCs which can be seen using Maya Purple pc_get_group_level(sd) < battle_config.hack_info_GM_level ) { @@ -9712,144 +9812,108 @@ int clif_undisguise_timer(int tid, int64 tick, int id, intptr_t data) { return 0; } -void clif_parse_GlobalMessage(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); -/// Validates and processes global messages -/// 008c <packet len>.W <text>.?B (<name> : <message>) 00 (CZ_REQUEST_CHAT) -/// There are various variants of this packet. -void clif_parse_GlobalMessage(int fd, struct map_session_data* sd) +/** + * Validates and processed global messages. + * + * There are various variants of this packet. + * + * @code + * 008c <packet len>.W <text>.?B (<name> : <message>) 00 (CZ_REQUEST_CHAT) + * @endcode + * + * @param fd The incoming file descriptor. + * @param sd The related character. + */ +void clif_parse_GlobalMessage(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); +void clif_parse_GlobalMessage(int fd, struct map_session_data *sd) { - const char *text = RFIFOP(fd,4); - size_t textlen = RFIFOW(fd,2) - 4; + const struct packet_chat_message *packet = NULL; + char full_message[CHAT_SIZE_MAX + NAME_LENGTH + 3 + 1]; + const char *message = NULL; + bool is_fakename = false; + int outlen = 0; - const char *name = NULL, *message = NULL; - char *fakename = NULL; - size_t namelen, messagelen; - - bool is_fake; - - // validate packet and retrieve name and message - if( !clif->process_message(sd, 0, &name, &namelen, &message, &messagelen) ) + packet = RP2PTR(fd); + message = clif->process_chat_message(sd, packet, full_message, sizeof full_message); + if (message == NULL) return; - if( atcommand->exec(fd, sd, message, true) ) - return; + pc->check_supernovice_call(sd, message); - if( !pc->can_talk(sd) ) + if (sd->gcbind != NULL) { + channel->send(sd->gcbind, sd, message); return; - - if( battle_config.min_chat_delay ) { //[Skotlex] - if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) - return; - sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; } - if( (sd->class_&MAPID_UPPERMASK) == MAPID_SUPER_NOVICE ) { - unsigned int next = pc->nextbaseexp(sd); - if( next == 0 ) next = pc->thisbaseexp(sd); - if( next ) { // 0%, 10%, 20%, ... - int percent = (int)( ( (float)sd->status.base_exp/(float)next )*1000. ); - if( (battle_config.snovice_call_type || percent) && ( percent%100 ) == 0 ) {// 10.0%, 20.0%, ..., 90.0% - switch (sd->state.snovice_call_flag) { - case 0: - if( strstr(message, msg_txt(1479)) ) // "Dear angel, can you hear my voice?" - sd->state.snovice_call_flag = 1; - break; - case 1: { - char buf[256]; - snprintf(buf, 256, msg_txt(1480), sd->status.name); - if( strstr(message, buf) ) // "I am %s Super Novice~" - sd->state.snovice_call_flag = 2; - } - break; - case 2: - if( strstr(message, msg_txt(1481)) ) // "Help me out~ Please~ T_T" - sd->state.snovice_call_flag = 3; - break; - case 3: - sc_start(NULL,&sd->bl, status->skill2sc(MO_EXPLOSIONSPIRITS), 100, 17, skill->get_time(MO_EXPLOSIONSPIRITS, 5)); //Lv17-> +50 critical (noted by Poki) [Skotlex] - clif->skill_nodamage(&sd->bl, &sd->bl, MO_EXPLOSIONSPIRITS, 5, 1); // prayer always shows successful Lv5 cast and disregards noskill restrictions - sd->state.snovice_call_flag = 0; - break; - } - } - } + if (sd->fakename[0] != '\0') { + is_fakename = true; + outlen = (int)strlen(sd->fakename) + (int)strlen(message) + 3 + 1; + } else { + outlen = (int)strlen(full_message) + 1; } - pc->update_idle_time(sd, BCIDLE_CHAT); - - if( sd->gcbind ) { - channel->send(sd->gcbind,sd,message); - return; - } else if ( sd->fontcolor && !sd->chatID ) { - char mout[200]; - unsigned char mylen = 1; + if (sd->fontcolor != 0 && sd->chat_id == 0) { uint32 color = 0; - if( sd->disguise == -1 ) { + if (sd->disguise == -1) { sd->fontcolor_tid = timer->add(timer->gettick()+5000, clif->undisguise_timer, sd->bl.id, 0); pc->disguise(sd,sd->status.class_); - if( pc_isdead(sd) ) + if (pc_isdead(sd)) clif->clearunit_single(-sd->bl.id, CLR_DEAD, sd->fd); - if( unit->is_walking(&sd->bl) ) + if (unit->is_walking(&sd->bl)) clif->move(&sd->ud); - } else if ( sd->disguise == sd->status.class_ && sd->fontcolor_tid != INVALID_TIMER ) { + } else if (sd->disguise == sd->status.class_ && sd->fontcolor_tid != INVALID_TIMER) { const struct TimerData *td; - if( (td = timer->get(sd->fontcolor_tid)) ) { + if ((td = timer->get(sd->fontcolor_tid)) != NULL) timer->settick(sd->fontcolor_tid, td->tick+5000); - } } - mylen += snprintf(mout, 200, "%s : %s",sd->fakename[0]?sd->fakename:sd->status.name,message); - color = channel->config->colors[sd->fontcolor - 1]; - WFIFOHEAD(fd,mylen + 12); + WFIFOHEAD(fd, outlen + 12); WFIFOW(fd,0) = 0x2C1; - WFIFOW(fd,2) = mylen + 12; + WFIFOW(fd,2) = outlen + 12; WFIFOL(fd,4) = sd->bl.id; WFIFOL(fd,8) = RGB2BGR(color); - safestrncpy(WFIFOP(fd,12), mout, mylen); + if (is_fakename) + safesnprintf(WFIFOP(fd, 12), outlen, "%s : %s", sd->fakename, message); + else + safestrncpy(WFIFOP(fd, 12), full_message, outlen); clif->send(WFIFOP(fd,0), WFIFOW(fd,2), &sd->bl, AREA_WOS); WFIFOL(fd,4) = -sd->bl.id; - WFIFOSET(fd, mylen + 12); + WFIFOSET(fd, outlen + 12); return; } - /** - * Fake Name Design by FatalEror (bug report #9) - **/ - if( ( is_fake = ( sd->fakename[0] ) ) ) { - fakename = (char*) aMalloc(strlen(sd->fakename)+messagelen+3); - strcpy(fakename, sd->fakename); - strcat(fakename, " : "); - strcat(fakename, message); - textlen = strlen(fakename) + 1; + { + // send message to others + void *buf = aMalloc(8 + outlen); + WBUFW(buf, 0) = 0x8d; + WBUFW(buf, 2) = 8 + outlen; + WBUFL(buf, 4) = sd->bl.id; + if (is_fakename) + safesnprintf(WBUFP(buf, 8), outlen, "%s : %s", sd->fakename, message); + else + safestrncpy(WBUFP(buf, 8), full_message, outlen); + //FIXME: chat has range of 9 only + clif->send(buf, WBUFW(buf, 2), &sd->bl, sd->chat_id != 0 ? CHAT_WOS : AREA_CHAT_WOC); + aFree(buf); } - // send message to others (using the send buffer for temp. storage) - WFIFOHEAD(fd, 8 + textlen); - WFIFOW(fd,0) = 0x8d; - WFIFOW(fd,2) = 8 + textlen; - WFIFOL(fd,4) = sd->bl.id; - safestrncpy(WFIFOP(fd,8), is_fake ? fakename : text, textlen); - //FIXME: chat has range of 9 only - clif->send(WFIFOP(fd,0), WFIFOW(fd,2), &sd->bl, sd->chatID ? CHAT_WOS : AREA_CHAT_WOC); // send back message to the speaker - if( is_fake ) { - WFIFOW(fd,0) = 0x8e; - WFIFOW(fd,2) = textlen + 4; - safestrncpy(WFIFOP(fd,4), fakename, textlen); - aFree(fakename); - } else { - memcpy(WFIFOP(fd,0), RFIFOP(fd,0), RFIFOW(fd,2)); - WFIFOW(fd,0) = 0x8e; - } + WFIFOHEAD(fd, 4 + outlen); + WFIFOW(fd, 0) = 0x8e; + WFIFOW(fd, 2) = 4 + outlen; + if (is_fakename) + safesnprintf(WFIFOP(fd, 4), outlen, "%s : %s", sd->fakename, message); + else + safestrncpy(WFIFOP(fd, 4), full_message, outlen); WFIFOSET(fd, WFIFOW(fd,2)); // Chat logging type 'O' / Global Chat logs->chat(LOG_CHAT_GLOBAL, 0, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, NULL, message); // trigger listening npcs - map->foreachinrange(npc_chat->sub, &sd->bl, AREA_SIZE, BL_NPC, text, textlen, &sd->bl); + map->foreachinrange(npc_chat->sub, &sd->bl, AREA_SIZE, BL_NPC, full_message, strlen(full_message), &sd->bl); } void clif_parse_MapMove(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); @@ -9893,7 +9957,7 @@ void clif_changed_dir(struct block_list *bl, enum send_target target) clif->send(buf, packet_len(0x9c), bl, target); - if (disguised(bl)) { + if (clif->isdisguised(bl)) { WBUFL(buf,2) = -bl->id; WBUFW(buf,6) = 0; clif->send(buf, packet_len(0x9c), bl, SELF); @@ -10122,37 +10186,28 @@ void clif_parse_Restart(int fd, struct map_session_data *sd) { } } -void clif_parse_WisMessage(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); -/// Validates and processes whispered messages (CZ_WHISPER). -/// 0096 <packet len>.W <nick>.24B <message>.?B +/** + * Validates and processes whispered messages (CZ_WHISPER). + * + * @code + * 0096 <packet len>.W <nick>.24B <message>.?B + * @endcode + * + * @param fd The incoming file descriptor. + * @param sd The related character. + */ +void clif_parse_WisMessage(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); void clif_parse_WisMessage(int fd, struct map_session_data* sd) { struct map_session_data* dstsd; int i; - const char *target, *message; - size_t namelen, messagelen; - - // validate packet and retrieve name and message - if( !clif->process_message(sd, 1, &target, &namelen, &message, &messagelen) ) - return; + char target[NAME_LENGTH], message[CHAT_SIZE_MAX + 1]; + const struct packet_whisper_message *packet = RP2PTR(fd); - if ( atcommand->exec(fd, sd, message, true) ) + if (!clif->process_whisper_message(sd, packet, target, message, sizeof message)) return; - // Statuses that prevent the player from whispering - if( !pc->can_talk(sd) ) - return; - - if (battle_config.min_chat_delay) { //[Skotlex] - if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) { - return; - } - sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; - } - - pc->update_idle_time(sd, BCIDLE_CHAT); - // Chat logging type 'W' / Whisper logs->chat(LOG_CHAT_WHISPER, 0, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, target, message); @@ -10222,7 +10277,7 @@ void clif_parse_WisMessage(int fd, struct map_session_data* sd) // if there are 'Test' player on an other map-server and 'test' player on this map-server, // and if we ask for 'Test', we must not contact 'test' player // so, we send information to inter-server, which is the only one which decide (and copy correct name). - intif->wis_message(sd, target, message, messagelen); + intif->wis_message(sd, target, message, (int)strlen(message)); return; } @@ -10236,10 +10291,10 @@ void clif_parse_WisMessage(int fd, struct map_session_data* sd) } // if player is autotrading - if( dstsd->state.autotrade ) { + if (dstsd->state.autotrade) { char output[256]; sprintf(output, "%s is in autotrade mode and cannot receive whispered messages.", dstsd->status.name); - clif->wis_message(fd, map->wisp_server_name, output, strlen(output) + 1); + clif->wis_message(fd, map->wisp_server_name, output, (int)strlen(output)); return; } @@ -10256,7 +10311,7 @@ void clif_parse_WisMessage(int fd, struct map_session_data* sd) clif->wis_end(fd, 0); // 0: success to send wisper // Normal message - clif->wis_message(dstsd->fd, sd->status.name, message, messagelen); + clif->wis_message(dstsd->fd, sd->status.name, message, (int)strlen(message)); } void clif_parse_Broadcast(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); @@ -10373,7 +10428,7 @@ void clif_parse_UseItem(int fd, struct map_session_data *sd) return; } - if ( (!sd->npc_id && pc_istrading(sd)) || sd->chatID ) + if ((!sd->npc_id && pc_istrading(sd)) || sd->chat_id != 0) return; //Whether the item is used or not is irrelevant, the char ain't idle. [Skotlex] @@ -10733,10 +10788,10 @@ void clif_noask_sub(struct map_session_data *src, struct map_session_data *targe nullpo_retv(src); // Your request has been rejected by autoreject option. msg = msg_sd(src,392); - clif_disp_onlyself(src, msg, strlen(msg)); + clif_disp_onlyself(src, msg); //Notice that a request was rejected. snprintf(output, 256, msg_sd(target,393+type), src->status.name, 256); - clif_disp_onlyself(target, output, strlen(output)); + clif_disp_onlyself(target, output); } void clif_parse_TradeRequest(int fd,struct map_session_data *sd) __attribute__((nonnull (2))); @@ -10747,7 +10802,7 @@ void clif_parse_TradeRequest(int fd,struct map_session_data *sd) { t_sd = map->id2sd(RFIFOL(fd,2)); - if(!sd->chatID && pc_cant_act(sd)) + if (sd->chat_id == 0 && pc_cant_act(sd)) return; //You can trade while in a chatroom. // @noask [LuzZza] @@ -11145,7 +11200,7 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd) sd->skillitem = sd->skillitemlv = 0; - if( skill_id >= GD_SKILLBASE ) { + if (skill_id >= GD_SKILLBASE && skill_id < GD_MAX) { if( sd->state.gmaster_flag ) skill_lv = guild->checkskill(sd->guild, skill_id); else @@ -11519,10 +11574,10 @@ void clif_parse_OneClick_ItemIdentify(int fd, struct map_session_data *sd) int cmd = RFIFOW(fd,0); short idx = RFIFOW(fd, packet_db[cmd].pos[0]) - 2; int n; - + if (idx < 0 || idx >= MAX_INVENTORY || sd->inventory_data[idx] == NULL || sd->status.inventory[idx].nameid <= 0) return; - + if ((n = pc->have_magnifier(sd) ) != INDEX_NOT_FOUND && pc->delitem(sd, n, 1, 0, DELITEM_NORMAL, LOG_TYPE_CONSUME) == 0) skill->identify(sd, idx); @@ -11952,36 +12007,26 @@ void clif_parse_PartyChangeOption(int fd, struct map_session_data *sd) #endif } -void clif_parse_PartyMessage(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); -/// Validates and processes party messages (CZ_REQUEST_CHAT_PARTY). -/// 0108 <packet len>.W <text>.?B (<name> : <message>) 00 -void clif_parse_PartyMessage(int fd, struct map_session_data* sd) +/** + * Validates and processes party messages (CZ_REQUEST_CHAT_PARTY). + * + * @code + * 0108 <packet len>.W <text>.?B (<name> : <message>) 00 + * @endcode + * + * @param fd The incoming file descriptor. + * @param sd The related character. + */ +void clif_parse_PartyMessage(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); +void clif_parse_PartyMessage(int fd, struct map_session_data *sd) { - const char *text = RFIFOP(fd,4); - int textlen = RFIFOW(fd,2) - 4; + const struct packet_chat_message *packet = RP2PTR(fd); + char message[CHAT_SIZE_MAX + NAME_LENGTH + 3 + 1]; - const char *name, *message; - size_t namelen, messagelen; - - // validate packet and retrieve name and message - if( !clif->process_message(sd, 0, &name, &namelen, &message, &messagelen) ) - return; - - if( atcommand->exec(fd, sd, message, true) ) + if (clif->process_chat_message(sd, packet, message, sizeof message) == NULL) return; - if( !pc->can_talk(sd) ) - return; - - if (battle_config.min_chat_delay) { - if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) - return; - sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; - } - - pc->update_idle_time(sd, BCIDLE_CHAT); - - party->send_message(sd, text, textlen); + party->send_message(sd, message); } void clif_parse_PartyChangeLeader(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); @@ -12823,7 +12868,7 @@ bool clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) { //uint8 b; //uint8 g; //uint8 r; - unsigned int rgb:24; + uint32 rgb:24; } __attribute__((packed)); #if !defined(sun) && (!defined(__NETBSD__) || __NetBSD_Version__ >= 600000000) // NetBSD 5 and Solaris don't like pragma pack but accept the packed attribute #pragma pack(pop) @@ -13060,39 +13105,29 @@ void clif_parse_GuildExpulsion(int fd,struct map_session_data *sd) { guild->expulsion(sd, RFIFOL(fd,2), RFIFOL(fd,6), RFIFOL(fd,10), RFIFOP(fd,14)); } -void clif_parse_GuildMessage(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); -/// Validates and processes guild messages (CZ_GUILD_CHAT). -/// 017e <packet len>.W <text>.?B (<name> : <message>) 00 -void clif_parse_GuildMessage(int fd, struct map_session_data* sd) +/** + * Validates and processes guild messages (CZ_GUILD_CHAT). + * + * @code + * 017e <packet len>.W <text>.?B (<name> : <message>) 00 + * @endcode + * + * @param fd The incoming file descriptor. + * @param sd The related character. + */ +void clif_parse_GuildMessage(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); +void clif_parse_GuildMessage(int fd, struct map_session_data *sd) { - const char *text = RFIFOP(fd,4); - int textlen = RFIFOW(fd,2) - 4; + const struct packet_chat_message *packet = RP2PTR(fd); + char message[CHAT_SIZE_MAX + NAME_LENGTH + 3 + 1]; - const char *name, *message; - size_t namelen, messagelen; - - // validate packet and retrieve name and message - if( !clif->process_message(sd, 0, &name, &namelen, &message, &messagelen) ) - return; - - if( atcommand->exec(fd, sd, message, true) ) + if (clif->process_chat_message(sd, packet, message, sizeof message) == NULL) return; - if( !pc->can_talk(sd) ) - return; - - if (battle_config.min_chat_delay) { - if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) - return; - sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; - } - - pc->update_idle_time(sd, BCIDLE_CHAT); - - if( sd->bg_id ) - bg->send_message(sd, text, textlen); + if (sd->bg_id) + bg->send_message(sd, message); else - guild->send_message(sd, text, textlen); + guild->send_message(sd, message); } void clif_parse_GuildRequestAlliance(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); @@ -14674,7 +14709,7 @@ void clif_Mail_refreshinbox(struct map_session_data *sd) if( md->full ) {// TODO: is this official? char output[100]; sprintf(output, "Inbox is full (Max %d). Delete some mails.", MAIL_MAX_INBOX); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); } } @@ -14712,11 +14747,16 @@ void clif_Mail_read(struct map_session_data *sd, int mail_id) struct mail_message *msg = &sd->mail.inbox.msg[i]; struct item *item = &msg->item; struct item_data *data; - size_t msg_len = strlen(msg->body), len; + int msg_len = (int)strlen(msg->body), len; - if( msg_len == 0 ) { + if (msg_len == 0) { strcpy(msg->body, "(no message)"); - msg_len = strlen(msg->body); + msg_len = (int)strlen(msg->body); + } + + if (msg_len > UINT8_MAX) { + Assert_report(msg_len > UINT8_MAX); + msg_len = UINT8_MAX; } len = 101 + msg_len; @@ -14744,7 +14784,7 @@ void clif_Mail_read(struct map_session_data *sd, int mail_id) } else // no item, set all to zero memset(WFIFOP(fd,80), 0x00, 19); - WFIFOB(fd,99) = (unsigned char)msg_len; + WFIFOB(fd,99) = (uint8)msg_len; safestrncpy(WFIFOP(fd,100), msg->body, msg_len + 1); WFIFOSET(fd,len); @@ -14778,7 +14818,6 @@ void clif_parse_Mail_getattach(int fd, struct map_session_data *sd) { int mail_id = RFIFOL(fd,2); int i; - bool fail = false; if( !chrif->isconnected() ) return; @@ -14802,6 +14841,7 @@ void clif_parse_Mail_getattach(int fd, struct map_session_data *sd) if( sd->mail.inbox.msg[i].item.nameid > 0 ) { struct item_data *data; unsigned int weight; + bool fail = false; if ((data = itemdb->exists(sd->mail.inbox.msg[i].item.nameid)) == NULL) return; @@ -16151,58 +16191,53 @@ void clif_bg_xy_remove(struct map_session_data *sd) /// Notifies clients of a battleground message (ZC_BATTLEFIELD_CHAT). /// 02dc <packet len>.W <account id>.L <name>.24B <message>.?B -void clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes, size_t len) +void clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes) { struct map_session_data *sd; unsigned char *buf; + int len; nullpo_retv(bgd); nullpo_retv(name); nullpo_retv(mes); - if( !bgd->count || (sd = bg->getavailablesd(bgd)) == NULL ) + + if (!bgd->count || (sd = bg->getavailablesd(bgd)) == NULL) return; + len = (int)strlen(mes); + Assert_retv(len <= INT16_MAX - NAME_LENGTH - 8); buf = (unsigned char*)aMalloc((len + NAME_LENGTH + 8)*sizeof(unsigned char)); WBUFW(buf,0) = 0x2dc; WBUFW(buf,2) = len + NAME_LENGTH + 8; WBUFL(buf,4) = src_id; memcpy(WBUFP(buf,8), name, NAME_LENGTH); - memcpy(WBUFP(buf,32), mes, len); + memcpy(WBUFP(buf,32), mes, len); // [!] no NUL terminator clif->send(buf,WBUFW(buf,2), &sd->bl, BG); aFree(buf); } -void clif_parse_BattleChat(int fd, struct map_session_data* sd) __attribute__((nonnull (2))); -/// Validates and processes battlechat messages [pakpil] (CZ_BATTLEFIELD_CHAT). -/// 0x2db <packet len>.W <text>.?B (<name> : <message>) 00 -void clif_parse_BattleChat(int fd, struct map_session_data* sd) +/** + * Validates and processes battlechat messages [pakpil] (CZ_BATTLEFIELD_CHAT). + * + * @code + * 0x2db <packet len>.W <text>.?B (<name> : <message>) 00 + * @endcode + * + * @param fd The incoming file descriptor. + * @param sd The related character. + */ +void clif_parse_BattleChat(int fd, struct map_session_data *sd) __attribute__((nonnull (2))); +void clif_parse_BattleChat(int fd, struct map_session_data *sd) { - const char *text = RFIFOP(fd,4); - int textlen = RFIFOW(fd,2) - 4; - - const char *name, *message; - size_t namelen, messagelen; + const struct packet_chat_message *packet = RP2PTR(fd); + char message[CHAT_SIZE_MAX + NAME_LENGTH + 3 + 1]; - if( !clif->process_message(sd, 0, &name, &namelen, &message, &messagelen) ) + if (clif->process_chat_message(sd, packet, message, sizeof message) == NULL) return; - if( atcommand->exec(fd, sd, message, true) ) - return; - - if( !pc->can_talk(sd) ) - return; - - if( battle_config.min_chat_delay ) { - if( DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0 ) - return; - sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; - } - - pc->update_idle_time(sd, BCIDLE_CHAT); - - bg->send_message(sd, text, textlen); + bg->send_message(sd, message); } /// Notifies client of a battleground score change (ZC_BATTLEFIELD_NOTIFY_POINT). @@ -17697,26 +17732,27 @@ void clif_partytickack(struct map_session_data* sd, bool flag) { WFIFOSET(sd->fd, packet_len(0x2c9)); } -void clif_ShowScript(struct block_list* bl, const char* message) { +void clif_ShowScript(struct block_list *bl, const char *message) +{ char buf[256]; - size_t len; + int len; nullpo_retv(bl); - if(!message) + if (message == NULL) return; - len = strlen(message)+1; + len = (int)strlen(message)+1; - if (len > sizeof(buf)-8) { - ShowWarning("clif_ShowScript: Truncating too long message '%s' (len=%"PRIuS").\n", message, len); - len = sizeof(buf)-8; + if (len > (int)sizeof(buf)-8) { + ShowWarning("clif_ShowScript: Truncating too long message '%s' (len=%d).\n", message, len); + len = (int)sizeof(buf)-8; } - WBUFW(buf,0)=0x8b3; - WBUFW(buf,2)=len+8; - WBUFL(buf,4)=bl->id; + WBUFW(buf,0) = 0x8b3; + WBUFW(buf,2) = len+8; + WBUFL(buf,4) = bl->id; safestrncpy(WBUFP(buf,8),message,len); - clif->send((unsigned char *) buf,WBUFW(buf,2),bl,ALL_CLIENT); + clif->send(buf,WBUFW(buf,2),bl,ALL_CLIENT); } void clif_status_change_end(struct block_list *bl, int tid, enum send_target target, int type) { @@ -17811,7 +17847,6 @@ void clif_parse_bgqueue_checkstate(int fd, struct map_session_data *sd) { const struct packet_bgqueue_checkstate *p = RP2PTR(fd); - nullpo_retv(sd); if (sd->bg_queue.arena && sd->bg_queue.type) { clif->bgqueue_update_info(sd,sd->bg_queue.arena->id,bg->id2pos(sd->bg_queue.arena->queue_id,sd->status.account_id)); } else { @@ -18062,7 +18097,7 @@ void clif_show_modifiers (struct map_session_data *sd) { snprintf(output,128,"Base EXP : %d%% | Base Drop: %d%% | Base Death Penalty: %d%%", sd->status.mod_exp,sd->status.mod_drop,sd->status.mod_death); - clif->broadcast2(&sd->bl,output, strlen(output) + 1, 0xffbc90, 0x190, 12, 0, 0, SELF); + clif->broadcast2(&sd->bl, output, (int)strlen(output) + 1, 0xffbc90, 0x190, 12, 0, 0, SELF); } } @@ -19365,7 +19400,8 @@ void clif_defaults(void) { clif->message = clif_displaymessage; clif->messageln = clif_displaymessage2; clif->messages = clif_displaymessage_sprintf; - clif->process_message = clif_process_message; + clif->process_chat_message = clif_process_chat_message; + clif->process_whisper_message = clif_process_whisper_message; clif->wisexin = clif_wisexin; clif->wisall = clif_wisall; clif->PMIgnoreList = clif_PMIgnoreList; @@ -19602,6 +19638,9 @@ void clif_defaults(void) { clif->ackmergeitems = clif_ackmergeitems; /* Cart Deco */ clif->selectcart = clif_selectcart; + /* */ + clif->isdisguised = clif_isdisguised; + clif->bl_type = clif_bl_type; /*------------------------ *- Parse Incoming Packet diff --git a/src/map/clif.h b/src/map/clif.h index f930e4ca1..df8b8f59c 100644 --- a/src/map/clif.h +++ b/src/map/clif.h @@ -60,7 +60,7 @@ struct view_data; **/ #define packet_len(cmd) packet_db[cmd].len #define clif_menuskill_clear(sd) ((sd)->menuskill_id = (sd)->menuskill_val = (sd)->menuskill_val2 = 0) -#define clif_disp_onlyself(sd,mes,len) clif->disp_message( &(sd)->bl, (mes), (len), SELF ) +#define clif_disp_onlyself(sd, mes) clif->disp_message(&(sd)->bl, (mes), SELF) #define MAX_ROULETTE_LEVEL 7 /** client-defined value **/ #define MAX_ROULETTE_COLUMNS 9 /** client-defined value **/ #define RGB2BGR(c) (((c) & 0x0000FF) << 16 | ((c) & 0x00FF00) | ((c) & 0xFF0000) >> 16) @@ -520,7 +520,7 @@ enum CLOSE_ROULETTE_ACK { /** * Reason for item deletion (clif->delitem) - */ + **/ enum delitem_reason { DELITEM_NORMAL = 0, /// Normal DELITEM_SKILLUSE = 1, /// Item used for a skill @@ -532,9 +532,9 @@ enum delitem_reason { DELITEM_ANALYSIS = 7, /// Consumed by Four Spirit Analysis (SO_EL_ANALYSIS) skill }; -/* -* Merge items reasons -*/ +/** + * Merge items reasons + **/ enum mergeitem_reason { MERGEITEM_SUCCESS = 0x0, @@ -543,6 +543,23 @@ enum mergeitem_reason { }; /** + * Clif Unit Type + **/ +enum clif_unittype { + CLUT_PC = 0x0, + CLUT_NPC = 0x1, + CLUT_ITEM = 0x2, + CLUT_SKILL = 0x3, + CLUT_UNKNOWN = 0x4, + CLUT_MOB = 0x5, + CLUT_EVENT = 0x6, + CLUT_PET = 0x7, + CLUT_HOMNUCLUS = 0x8, + CLUT_MERCNARY = 0x9, + CLUT_ELEMENTAL = 0xa, +}; + +/** * Structures **/ typedef void (*pFunc)(int, struct map_session_data *); //cant help but put it first @@ -563,8 +580,8 @@ struct cdelayed_damage { }; struct merge_item { - int16 position; - int16 nameid; + int16 position; + int16 nameid; }; /** @@ -841,11 +858,11 @@ struct clif_interface { void (*clearchat) (struct chat_data *cd,int fd); void (*leavechat) (struct chat_data* cd, struct map_session_data* sd, bool flag); void (*changechatstatus) (struct chat_data* cd); - void (*wis_message) (int fd, const char* nick, const char* mes, size_t mes_len); + void (*wis_message) (int fd, const char *nick, const char *mes, int mes_len); void (*wis_end) (int fd, int flag); - void (*disp_message) (struct block_list* src, const char* mes, size_t len, enum send_target target); - void (*broadcast) (struct block_list* bl, const char* mes, size_t len, int type, enum send_target target); - void (*broadcast2) (struct block_list* bl, const char* mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target); + void (*disp_message) (struct block_list *src, const char *mes, enum send_target target); + void (*broadcast) (struct block_list *bl, const char *mes, int len, int type, enum send_target target); + void (*broadcast2) (struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target); void (*messagecolor_self) (int fd, uint32 color, const char *msg); void (*messagecolor) (struct block_list* bl, uint32 color, const char* msg); void (*disp_overhead) (struct block_list *bl, const char* mes); @@ -856,7 +873,8 @@ struct clif_interface { void (*messageln) (const int fd, const char* mes); /* message+s(printf) */ void (*messages) (const int fd, const char *mes, ...) __attribute__((format(printf, 2, 3))); - bool (*process_message) (struct map_session_data *sd, int format, const char **name_, size_t *namelen_, const char **message_, size_t *messagelen_); + const char *(*process_chat_message) (struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen); + bool (*process_whisper_message) (struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen); void (*wisexin) (struct map_session_data *sd,int type,int flag); void (*wisall) (struct map_session_data *sd,int type,int flag); void (*PMIgnoreList) (struct map_session_data* sd); @@ -942,7 +960,7 @@ struct clif_interface { void (*bg_hp) (struct map_session_data *sd); void (*bg_xy) (struct map_session_data *sd); void (*bg_xy_remove) (struct map_session_data *sd); - void (*bg_message) (struct battleground_data *bgd, int src_id, const char *name, const char *mes, size_t len); + void (*bg_message) (struct battleground_data *bgd, int src_id, const char *name, const char *mes); void (*bg_updatescore) (int16 m); void (*bg_updatescore_single) (struct map_session_data *sd); void (*sendbgemblem_area) (struct map_session_data *sd); @@ -1090,7 +1108,9 @@ struct clif_interface { void (*cancelmergeitem) (int fd, struct map_session_data *sd); int (*comparemergeitem) (const void *a, const void *b); void (*ackmergeitems) (int fd, struct map_session_data *sd); - + /* */ + bool (*isdisguised) (struct block_list* bl); + unsigned char (*bl_type) (struct block_list *bl); /*------------------------ *- Parse Incoming Packet *------------------------*/ diff --git a/src/map/duel.c b/src/map/duel.c index c658ea3e3..64991d39c 100644 --- a/src/map/duel.c +++ b/src/map/duel.c @@ -73,7 +73,7 @@ static int duel_showinfo_sub(struct map_session_data* sd, va_list va) if (sd->duel_group != ssd->duel_group) return 0; sprintf(output, " %d. %s", ++(*p), sd->status.name); - clif_disp_onlyself(ssd, output, strlen(output)); + clif_disp_onlyself(ssd, output); return 1; } @@ -93,7 +93,7 @@ void duel_showinfo(const unsigned int did, struct map_session_data* sd) { duel->list[did].members_count, duel->list[did].members_count + duel->list[did].invites_count); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); map->foreachpc(duel_showinfo_sub, sd, &p); } @@ -113,7 +113,7 @@ int duel_create(struct map_session_data* sd, const unsigned int maxpl) { duel->list[i].max_players_limit = maxpl; safestrncpy(output, msg_sd(sd,372), sizeof(output)); // " -- Duel has been created (@invite/@leave) --" - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); clif->map_property(sd, MAPPROPERTY_FREEPVPZONE); clif->maptypeproperty2(&sd->bl,SELF); @@ -127,14 +127,14 @@ void duel_invite(const unsigned int did, struct map_session_data* sd, struct map nullpo_retv(target_sd); // " -- Player %s invites %s to duel --" sprintf(output, msg_sd(sd,373), sd->status.name, target_sd->status.name); - clif->disp_message(&sd->bl, output, strlen(output), DUEL_WOS); + clif->disp_message(&sd->bl, output, DUEL_WOS); target_sd->duel_invite = did; duel->list[did].invites_count++; // "Blue -- Player %s invites you to PVP duel (@accept/@reject) --" sprintf(output, msg_sd(target_sd,374), sd->status.name); - clif->broadcast(&target_sd->bl, output, strlen(output)+1, BC_BLUE, SELF); + clif->broadcast(&target_sd->bl, output, (int)strlen(output)+1, BC_BLUE, SELF); } static int duel_leave_sub(struct map_session_data* sd, va_list va) @@ -152,7 +152,7 @@ void duel_leave(const unsigned int did, struct map_session_data* sd) { nullpo_retv(sd); // " <- Player %s has left duel --" sprintf(output, msg_sd(sd,375), sd->status.name); - clif->disp_message(&sd->bl, output, strlen(output), DUEL_WOS); + clif->disp_message(&sd->bl, output, DUEL_WOS); duel->list[did].members_count--; if(duel->list[did].members_count == 0) { @@ -177,7 +177,7 @@ void duel_accept(const unsigned int did, struct map_session_data* sd) { // " -> Player %s has accepted duel --" sprintf(output, msg_sd(sd,376), sd->status.name); - clif->disp_message(&sd->bl, output, strlen(output), DUEL_WOS); + clif->disp_message(&sd->bl, output, DUEL_WOS); clif->map_property(sd, MAPPROPERTY_FREEPVPZONE); clif->maptypeproperty2(&sd->bl,SELF); @@ -189,7 +189,7 @@ void duel_reject(const unsigned int did, struct map_session_data* sd) { nullpo_retv(sd); // " -- Player %s has rejected duel --" sprintf(output, msg_sd(sd,377), sd->status.name); - clif->disp_message(&sd->bl, output, strlen(output), DUEL_WOS); + clif->disp_message(&sd->bl, output, DUEL_WOS); duel->list[did].invites_count--; sd->duel_invite = 0; diff --git a/src/map/guild.c b/src/map/guild.c index 39d580bb7..ae3887aca 100644 --- a/src/map/guild.c +++ b/src/map/guild.c @@ -399,8 +399,11 @@ int guild_created(int account_id,int guild_id) { //struct guild *g; sd->status.guild_id=guild_id; clif->guild_created(sd,0); // Success - if(battle_config.guild_emperium_check) - pc->delitem(sd, pc->search_inventory(sd, ITEMID_EMPERIUM), 1, 0, DELITEM_NORMAL, LOG_TYPE_CONSUME); //emperium consumption + if (battle_config.guild_emperium_check) { + int n = pc->search_inventory(sd, ITEMID_EMPERIUM); + if (n != INDEX_NOT_FOUND) + pc->delitem(sd, n, 1, 0, DELITEM_NORMAL, LOG_TYPE_CONSUME); //emperium consumption + } return 0; } @@ -1060,14 +1063,15 @@ int guild_recv_memberinfoshort(int guild_id,int account_id,int char_id,int onlin /*==================================================== * Send a message to whole guild *---------------------------------------------------*/ -int guild_send_message(struct map_session_data *sd,const char *mes,int len) +int guild_send_message(struct map_session_data *sd, const char *mes) { + int len = (int)strlen(mes); nullpo_ret(sd); - if(sd->status.guild_id==0) + if (sd->status.guild_id == 0) return 0; - intif->guild_message(sd->status.guild_id,sd->status.account_id,mes,len); - guild->recv_message(sd->status.guild_id,sd->status.account_id,mes,len); + intif->guild_message(sd->status.guild_id, sd->status.account_id, mes, len); + guild->recv_message(sd->status.guild_id, sd->status.account_id, mes, len); // Chat logging type 'G' / Guild Chat logs->chat(LOG_CHAT_GUILD, sd->status.guild_id, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, NULL, mes); @@ -1828,7 +1832,7 @@ int guild_gm_change(int guild_id, struct map_session_data *sd) return 0; //Notify servers that master has changed. - intif->guild_change_gm(guild_id, sd->status.name, strlen(sd->status.name)+1); + intif->guild_change_gm(guild_id, sd->status.name, (int)strlen(sd->status.name)+1); return 1; } diff --git a/src/map/guild.h b/src/map/guild.h index 1f3b74543..4fe7106d3 100644 --- a/src/map/guild.h +++ b/src/map/guild.h @@ -135,7 +135,7 @@ struct guild_interface { int (*notice_changed) (int guild_id,const char *mes1,const char *mes2); int (*change_emblem) (struct map_session_data *sd,int len,const char *data); int (*emblem_changed) (int len,int guild_id,int emblem_id,const char *data); - int (*send_message) (struct map_session_data *sd,const char *mes,int len); + int (*send_message) (struct map_session_data *sd, const char *mes); int (*recv_message) (int guild_id,int account_id,const char *mes,int len); int (*send_dot_remove) (struct map_session_data *sd); int (*skillupack) (int guild_id,uint16 skill_id,int account_id); diff --git a/src/map/homunculus.c b/src/map/homunculus.c index bda8fd9e6..66cce23e6 100644 --- a/src/map/homunculus.c +++ b/src/map/homunculus.c @@ -391,7 +391,7 @@ bool homunculus_levelup(struct homun_data *hd) { growth_max_hp, growth_max_sp, growth_str/10.0, growth_agi/10.0, growth_vit/10.0, growth_int/10.0, growth_dex/10.0, growth_luk/10.0); - clif_disp_onlyself(hd->master,output,strlen(output)); + clif_disp_onlyself(hd->master, output); } return true; } diff --git a/src/map/instance.c b/src/map/instance.c index a6700d486..fa2cfec16 100644 --- a/src/map/instance.c +++ b/src/map/instance.c @@ -551,7 +551,7 @@ void instance_destroy(int instance_id) { struct party_data *p = NULL; struct guild *g = NULL; short *iptr = NULL; - int type, j; + int type; unsigned int now = (unsigned int)time(NULL); if( !instance->valid(instance_id) ) @@ -596,9 +596,10 @@ void instance_destroy(int instance_id) { } if( iptr != NULL ) { - ARR_FIND(0, *icptr, j, iptr[j] == instance_id); - if( j != *icptr ) - iptr[j] = -1; + int i; + ARR_FIND(0, *icptr, i, iptr[i] == instance_id); + if (i != *icptr) + iptr[i] = -1; } if (instance->list[instance_id].map) { diff --git a/src/map/intif.c b/src/map/intif.c index ec0251dad..2d6d39406 100644 --- a/src/map/intif.c +++ b/src/map/intif.c @@ -150,7 +150,7 @@ int intif_rename(struct map_session_data *sd, int type, const char *name) } // GM Send a message -int intif_broadcast(const char* mes, size_t len, int type) +int intif_broadcast(const char *mes, int len, int type) { int lp = (type&BC_COLOR_MASK) ? 4 : 0; @@ -182,7 +182,7 @@ int intif_broadcast(const char* mes, size_t len, int type) return 0; } -int intif_broadcast2(const char* mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY) +int intif_broadcast2(const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY) { nullpo_ret(mes); Assert_ret(len < 32000); @@ -222,7 +222,7 @@ int intif_main_message(struct map_session_data* sd, const char* message) snprintf( output, sizeof(output), msg_txt(386), sd->status.name, message ); // send the message using the inter-server broadcast service - intif->broadcast2( output, strlen(output) + 1, 0xFE000000, 0, 0, 0, 0 ); + intif->broadcast2(output, (int)strlen(output) + 1, 0xFE000000, 0, 0, 0, 0); // log the chat message logs->chat( LOG_CHAT_MAINCHAT, 0, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, NULL, message ); @@ -231,7 +231,7 @@ int intif_main_message(struct map_session_data* sd, const char* message) } // The transmission of Wisp/Page to inter-server (player not found on this server) -int intif_wis_message(struct map_session_data *sd, const char *nick, const char *mes, size_t mes_len) +int intif_wis_message(struct map_session_data *sd, const char *nick, const char *mes, int mes_len) { if (intif->CheckForCharServer()) return 0; @@ -279,12 +279,14 @@ int intif_wis_replay(int id, int flag) // The transmission of GM only Wisp/Page from server to inter-server int intif_wis_message_to_gm(char *wisp_name, int permission, char *mes) { - size_t mes_len; + int mes_len; if (intif->CheckForCharServer()) return 0; nullpo_ret(wisp_name); nullpo_ret(mes); - mes_len = strlen(mes) + 1; // + null + mes_len = (int)strlen(mes) + 1; // + null + Assert_ret(mes_len > 0 && mes_len <= INT16_MAX - 32); + WFIFOHEAD(inter_fd, mes_len + 32); WFIFOW(inter_fd,0) = 0x3003; WFIFOW(inter_fd,2) = mes_len + 32; @@ -658,7 +660,7 @@ int intif_guild_addmember(int guild_id,struct guild_member *m) } // Request a new leader for guild -int intif_guild_change_gm(int guild_id, const char* name, size_t len) +int intif_guild_change_gm(int guild_id, const char *name, int len) { if (intif->CheckForCharServer()) return 0; @@ -986,7 +988,7 @@ void intif_parse_WisMessage(int fd) { return; } //Success to send whisper. - clif->wis_message(sd->fd, wisp_source, RFIFOP(fd,56),RFIFOW(fd,2)-56); + clif->wis_message(sd->fd, wisp_source, RFIFOP(fd,56),RFIFOW(fd,2)-57); intif_wis_replay(id,0); // success } @@ -1005,7 +1007,8 @@ void intif_parse_WisEnd(int fd) return; } -int mapif_parse_WisToGM_sub(struct map_session_data* sd,va_list va) { +int intif_parse_WisToGM_sub(struct map_session_data *sd, va_list va) +{ int permission = va_arg(va, int); char *wisp_name; char *message; @@ -1023,22 +1026,22 @@ int mapif_parse_WisToGM_sub(struct map_session_data* sd,va_list va) { // Received wisp message from map-server via char-server for ALL gm // 0x3003/0x3803 <packet_len>.w <wispname>.24B <permission>.l <message>.?B -void mapif_parse_WisToGM(int fd) +void intif_parse_WisToGM(int fd) { int permission, mes_len; char Wisp_name[NAME_LENGTH]; char mbuf[255] = { 0 }; char *message; - mes_len = RFIFOW(fd,2) - 32; + mes_len = RFIFOW(fd,2) - 33; // Length not including the NUL terminator Assert_retv(mes_len > 0 && mes_len < 32000); - message = (char *) (mes_len >= 255 ? (char *) aMalloc(mes_len) : mbuf); + message = (mes_len >= 255 ? aMalloc(mes_len + 1) : mbuf); permission = RFIFOL(fd,28); safestrncpy(Wisp_name, RFIFOP(fd,4), NAME_LENGTH); - safestrncpy(message, RFIFOP(fd,32), mes_len); + safestrncpy(message, RFIFOP(fd,32), mes_len + 1); // information is sent to all online GM - map->foreachpc(mapif_parse_WisToGM_sub, permission, Wisp_name, message, mes_len); + map->foreachpc(intif->pWisToGM_sub, permission, Wisp_name, message, mes_len); if (message != mbuf) aFree(message); @@ -1654,7 +1657,7 @@ void intif_parse_MailInboxReceived(int fd) { else if( battle_config.mail_show_status && ( battle_config.mail_show_status == 1 || sd->mail.inbox.unread ) ) { char output[128]; sprintf(output, msg_sd(sd,510), sd->mail.inbox.unchecked, sd->mail.inbox.unread + sd->mail.inbox.unchecked); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); } } /*------------------------------------------ @@ -2489,8 +2492,8 @@ void intif_defaults(void) { /* parse functions */ intif->pWisMessage = intif_parse_WisMessage; intif->pWisEnd = intif_parse_WisEnd; - intif->pWisToGM_sub = mapif_parse_WisToGM_sub; - intif->pWisToGM = mapif_parse_WisToGM; + intif->pWisToGM_sub = intif_parse_WisToGM_sub; + intif->pWisToGM = intif_parse_WisToGM; intif->pRegisters = intif_parse_Registers; intif->pChangeNameOk = intif_parse_ChangeNameOk; intif->pMessageToFD = intif_parse_MessageToFD; diff --git a/src/map/intif.h b/src/map/intif.h index dccd31d80..5e7f86fc2 100644 --- a/src/map/intif.h +++ b/src/map/intif.h @@ -59,10 +59,10 @@ struct intif_interface { int (*parse) (int fd); int (*create_pet)(int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, char *pet_name); - int (*broadcast) (const char* mes, size_t len, int type); - int (*broadcast2) (const char* mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY); + int (*broadcast) (const char *mes, int len, int type); + int (*broadcast2) (const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY); int (*main_message) (struct map_session_data* sd, const char* message); - int (*wis_message) (struct map_session_data *sd, const char *nick, const char *mes, size_t mes_len); + int (*wis_message) (struct map_session_data *sd, const char *nick, const char *mes, int mes_len); int (*wis_message_to_gm) (char *Wisp_name, int permission, char *mes); int (*saveregistry) (struct map_session_data *sd); int (*request_registry) (struct map_session_data *sd, int flag); @@ -84,7 +84,7 @@ struct intif_interface { int (*guild_memberinfoshort) (int guild_id, int account_id, int char_id, int online, int lv, int class_); int (*guild_break) (int guild_id); int (*guild_message) (int guild_id, int account_id, const char *mes, int len); - int (*guild_change_gm) (int guild_id, const char* name, size_t len); + int (*guild_change_gm) (int guild_id, const char *name, int len); int (*guild_change_basicinfo) (int guild_id, int type, const void *data, int len); int (*guild_change_memberinfo) (int guild_id, int account_id, int char_id, int type, const void *data, int len); int (*guild_position) (int guild_id, int idx, struct guild_position *p); diff --git a/src/map/irc-bot.c b/src/map/irc-bot.c index b520e9e91..5820ad2cf 100644 --- a/src/map/irc-bot.c +++ b/src/map/irc-bot.c @@ -48,10 +48,7 @@ struct irc_bot_interface *ircbot; char send_string[IRC_MESSAGE_LENGTH]; -/** - * Timer callback to (re-)connect to an IRC server - * @see timer->do_timer - */ +/// @copydoc irc_bot_interface::connect_timer() int irc_connect_timer(int tid, int64 tick, int id, intptr_t data) { struct hSockOpt opt; if( ircbot->isOn || ++ircbot->fails >= 3 ) @@ -71,53 +68,43 @@ int irc_connect_timer(int tid, int64 tick, int id, intptr_t data) { return 0; } -/** - * Timer callback to send identification commands to an IRC server - * @see timer->do_timer - */ +/// @copydoc irc_bot_interface::identify_timer() int irc_identify_timer(int tid, int64 tick, int id, intptr_t data) { if( !ircbot->isOn ) return 0; sprintf(send_string, "USER HerculesWS%d 8 * : Hercules IRC Bridge",rnd()%777); - ircbot->send(send_string); + ircbot->send(send_string, true); sprintf(send_string, "NICK %s", channel->config->irc_nick); - ircbot->send(send_string); + ircbot->send(send_string, true); timer->add(timer->gettick() + 3000, ircbot->join_timer, 0, 0); return 0; } -/** - * Timer callback to join channels (and optionally send NickServ commands) - * @see timer->do_timer - */ +/// @copydoc irc_bot_interface::join_timer() int irc_join_timer(int tid, int64 tick, int id, intptr_t data) { if( !ircbot->isOn ) return 0; if (channel->config->irc_nick_pw[0] != '\0') { sprintf(send_string, "PRIVMSG NICKSERV : IDENTIFY %s", channel->config->irc_nick_pw); - ircbot->send(send_string); + ircbot->send(send_string, true); if (channel->config->irc_use_ghost) { sprintf(send_string, "PRIVMSG NICKSERV : GHOST %s %s", channel->config->irc_nick, channel->config->irc_nick_pw); + ircbot->send(send_string, true); } } sprintf(send_string, "JOIN %s", channel->config->irc_channel); - ircbot->send(send_string); + ircbot->send(send_string, true); ircbot->isIn = true; return 0; } -/** - * Search the handler for a given IRC received command - * @param function_name Name of the received IRC command - * @return Function pointer to the command handler, NULL in case - * of unhandled commands - */ +/// @copydoc irc_bot_interface::func_search() struct irc_func* irc_func_search(char* function_name) { int i; nullpo_retr(NULL, function_name); @@ -129,10 +116,7 @@ struct irc_func* irc_func_search(char* function_name) { return NULL; } -/** - * Parser for the IRC server connection - * @see do_sockets - */ +/// @copydoc irc_bot_interface::parse() int irc_parse(int fd) { char *parse_string = NULL, *p = NULL, *str_safe = NULL; @@ -166,16 +150,7 @@ int irc_parse(int fd) { return 0; } -/** - * Parse the source from a received irc message - * @param source Source string, as reported by the server - * @param nick Pointer to a string where to return the nick (may not be NULL, - * needs to be able to fit an IRC_NICK_LENGTH long string) - * @param ident Pointer to a string where to return the ident (may not be - * NULL, needs to be able to fit an IRC_IDENT_LENGTH long string) - * @param host Pointer to a string where to return the hostname (may not be - * NULL, needs to be able to fit an IRC_HOST_LENGTH long string) - */ +/// @copydoc irc_bot_interface::parse_source() void irc_parse_source(char *source, char *nick, char *ident, char *host) { int i, pos = 0; size_t len; @@ -199,12 +174,7 @@ void irc_parse_source(char *source, char *nick, char *ident, char *host) { } } -/** - * Parse a received message from the irc server, and do the appropriate action - * for the detected command - * @param fd IRC server connection file descriptor - * @param str Raw received message - */ +/// @copydoc irc_bot_interface::parse_sub() void irc_parse_sub(int fd, char *str) { char source[180], command[60], buf1[IRC_MESSAGE_LENGTH], buf2[IRC_MESSAGE_LENGTH]; char *target = buf1, *message = buf2; @@ -234,35 +204,92 @@ void irc_parse_sub(int fd, char *str) { func->func(fd,command,source,target,message); } -/** - * Send a raw command to the irc server - * @param str Command to send - */ -void irc_send(char *str) { +/// @copydoc irc_bot_interface::queue() +void irc_queue(char *str) +{ + struct message_flood *queue_entry = NULL; + + if (!ircbot->flood_protection_enabled) { + ircbot->send(str, true); + return; + } + + if (ircbot->message_current == NULL) { + // No queue yet + if (ircbot->messages_burst_count < ircbot->flood_protection_burst) { + ircbot->send(str, true); + if (DIFF_TICK(timer->gettick(), ircbot->last_message_tick) <= ircbot->flood_protection_rate) + ircbot->messages_burst_count++; + else + ircbot->messages_burst_count = 0; + ircbot->last_message_tick = timer->gettick(); + } else { //queue starts + CREATE(queue_entry, struct message_flood, 1); + safestrncpy(queue_entry->message, str, sizeof(queue_entry->message)); + queue_entry->next = NULL; + ircbot->message_current = queue_entry; + ircbot->message_last = queue_entry; + ircbot->queue_tid = timer->add(timer->gettick() + ircbot->flood_protection_rate, ircbot->queue_timer, 0, 0); //start queue timer + ircbot->messages_burst_count = 0; + } + } else { + CREATE(queue_entry, struct message_flood, 1); + safestrncpy(queue_entry->message, str, sizeof(queue_entry->message)); + queue_entry->next = NULL; + ircbot->message_last->next = queue_entry; + ircbot->message_last = queue_entry; + } +} + +/// @copydoc irc_bot_interface::queue_timer() +int irc_queue_timer(int tid, int64 tick, int id, intptr_t data) +{ + struct message_flood *queue_entry = ircbot->message_current; + nullpo_ret(queue_entry); + + ircbot->send(queue_entry->message, true); + if (queue_entry->next != NULL) { + ircbot->message_current = queue_entry->next; + ircbot->queue_tid = timer->add(timer->gettick() + ircbot->flood_protection_rate, ircbot->queue_timer, 0, 0); + } else { + ircbot->message_current = NULL; + ircbot->message_last = NULL; + ircbot->queue_tid = INVALID_TIMER; + } + + aFree(queue_entry); + + return 0; +} + +/// @copydoc irc_bot_interface::send() +void irc_send(char *str, bool force) +{ size_t len; nullpo_retv(str); len = strlen(str) + 2; if (len > IRC_MESSAGE_LENGTH-3) len = IRC_MESSAGE_LENGTH-3; + + if (!force && ircbot->flood_protection_enabled) { + // Add to queue + ircbot->queue(str); + return; + } + WFIFOHEAD(ircbot->fd, len); snprintf(WFIFOP(ircbot->fd,0),IRC_MESSAGE_LENGTH, "%s\r\n", str); WFIFOSET(ircbot->fd, len); } -/** - * Handler for the PING IRC command (send back a PONG) - * @see irc_parse_sub - */ +/// @copydoc irc_interface_bot::pong() void irc_pong(int fd, char *cmd, char *source, char *target, char *msg) { nullpo_retv(cmd); snprintf(send_string, IRC_MESSAGE_LENGTH, "PONG %s", cmd); - ircbot->send(send_string); + ircbot->send(send_string, false); } -/** - * Handler for CTCP commands received via PRIVMSG - * @see irc_privmsg - */ +/// @copydoc irc_interface_bot::privmsg_ctcp() void irc_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) { char source_nick[IRC_NICK_LENGTH], source_ident[IRC_IDENT_LENGTH], source_host[IRC_HOST_LENGTH]; @@ -283,7 +310,7 @@ void irc_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) // Ignore it } else if( strcmpi(cmd,"PING") == 0 ) { snprintf(send_string, IRC_MESSAGE_LENGTH, "NOTICE %s :\001PING %s\001",source_nick,msg); - ircbot->send(send_string); + ircbot->send(send_string, false); } else if( strcmpi(cmd,"TIME") == 0 ) { time_t time_server; // variable for number of seconds (used with time() function) struct tm *datetime; // variable for time in structure ->tm_mday, ->tm_sec, ... @@ -297,10 +324,10 @@ void irc_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) strftime(temp, sizeof(temp)-1, msg_txt(230), datetime); // Server time (normal time): %A, %B %d %Y %X. snprintf(send_string, IRC_MESSAGE_LENGTH, "NOTICE %s :\001TIME %s\001",source_nick,temp); - ircbot->send(send_string); + ircbot->send(send_string, false); } else if( strcmpi(cmd,"VERSION") == 0 ) { snprintf(send_string, IRC_MESSAGE_LENGTH, "NOTICE %s :\001VERSION Hercules.ws IRC Bridge\001",source_nick); - ircbot->send(send_string); + ircbot->send(send_string, false); #ifdef IRCBOT_DEBUG } else { ShowWarning("Unknown CTCP command received %s (%s) from %s\n",cmd,msg,source); @@ -308,10 +335,7 @@ void irc_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) } } -/** - * Handler for the PRIVMSG IRC command (action depends on the message contents) - * @see irc_parse_sub - */ +/// @copydoc irc_bot_interface::privmsg() void irc_privmsg(int fd, char *cmd, char *source, char *target, char *msg) { size_t len = msg ? strlen(msg) : 0; nullpo_retv(source); @@ -322,7 +346,7 @@ void irc_privmsg(int fd, char *cmd, char *source, char *target, char *msg) { command[0] = message[0] = '\0'; sscanf(msg, "\001%499[^\001\r\n ] %499[^\r\n\001]\001", command, message); - irc_privmsg_ctcp(fd, command, source, target, message); + ircbot->privmsg_ctcp(fd, command, source, target, message); #ifdef IRCBOT_DEBUG } else if (strcmpi(target, channel->config->irc_nick) == 0) { ShowDebug("irc_privmsg: Received message from %s: '%s'\n", source ? source : "(null)", msg); @@ -349,11 +373,7 @@ void irc_privmsg(int fd, char *cmd, char *source, char *target, char *msg) { } } -/** - * Handler for the JOIN IRC command (notify an in-game channel of users joining - * the IRC channel) - * @see irc_parse_sub - */ +/// @copydoc irc_bot_interface::userjoin() void irc_userjoin(int fd, char *cmd, char *source, char *target, char *msg) { char source_nick[IRC_NICK_LENGTH], source_ident[IRC_IDENT_LENGTH], source_host[IRC_HOST_LENGTH]; @@ -369,11 +389,7 @@ void irc_userjoin(int fd, char *cmd, char *source, char *target, char *msg) { } } -/** - * Handler for the PART and QUIT IRC commands (notify an in-game channel of - * users leaving the IRC channel) - * @see irc_parse_sub - */ +/// @copydoc irc_bot_interface::userleave() void irc_userleave(int fd, char *cmd, char *source, char *target, char *msg) { char source_nick[IRC_NICK_LENGTH], source_ident[IRC_IDENT_LENGTH], source_host[IRC_HOST_LENGTH]; @@ -392,11 +408,7 @@ void irc_userleave(int fd, char *cmd, char *source, char *target, char *msg) { } } -/** - * Handler for the NICK IRC commands (notify an in-game channel of users - * changing their name while in the IRC channel) - * @see irc_parse_sub - */ +/// @copydoc irc_bot_interface::usernick() void irc_usernick(int fd, char *cmd, char *source, char *target, char *msg) { char source_nick[IRC_NICK_LENGTH], source_ident[IRC_IDENT_LENGTH], source_host[IRC_HOST_LENGTH]; @@ -412,11 +424,7 @@ void irc_usernick(int fd, char *cmd, char *source, char *target, char *msg) { } } -/** - * Relay a chat message to the irc channel the bot is connected to - * @param name Sender's name - * @param msg Message text - */ +/// @copydoc irc_bot_interface::relay() void irc_relay(const char *name, const char *msg) { if (!ircbot->isIn) @@ -428,12 +436,10 @@ void irc_relay(const char *name, const char *msg) else sprintf(send_string,"PRIVMSG %s :%s", channel->config->irc_channel, msg); - ircbot->send(send_string); + ircbot->send(send_string, false); } -/** - * IRC bot initializer - */ +/// @copydoc irc_bot_interface::init() void irc_bot_init(bool minimal) { /// Command handlers const struct irc_func irc_func_base[] = { @@ -479,22 +485,31 @@ void irc_bot_init(bool minimal) { ircbot->isOn = false; timer->add_func_list(ircbot->connect_timer, "irc_connect_timer"); + timer->add_func_list(ircbot->queue_timer, "irc_queue_timer"); + timer->add(timer->gettick() + 7000, ircbot->connect_timer, 0, 0); } -/** - * IRC bot finalizer - */ +/// @copydoc irc_bot_interface::final() void irc_bot_final(void) { int i; if (!channel->config->irc) return; if( ircbot->isOn ) { - ircbot->send("QUIT :Hercules is shutting down"); + ircbot->send("QUIT :Hercules is shutting down", true); sockt->close(ircbot->fd); } + if (ircbot->queue_tid != INVALID_TIMER) + timer->delete(ircbot->queue_tid, ircbot->queue_timer); + + while (ircbot->message_current != NULL) { + struct message_flood *next = ircbot->message_current->next; + aFree(ircbot->message_current); + ircbot->message_current = next; + } + for( i = 0; i < ircbot->funcs.size; i++ ) { aFree(ircbot->funcs.list[i]); } @@ -509,6 +524,15 @@ void ircbot_defaults(void) { ircbot->channel = NULL; + ircbot->flood_protection_enabled = true; + ircbot->flood_protection_rate = 1000; + ircbot->flood_protection_burst = 3; + ircbot->last_message_tick = INVALID_TIMER; + ircbot->queue_tid = INVALID_TIMER; + ircbot->messages_burst_count = 0; + ircbot->message_current = NULL; + ircbot->message_last = NULL; + ircbot->init = irc_bot_init; ircbot->final = irc_bot_final; @@ -522,11 +546,14 @@ void ircbot_defaults(void) { ircbot->identify_timer = irc_identify_timer; ircbot->join_timer = irc_join_timer; + ircbot->queue_timer = irc_queue_timer; + ircbot->queue = irc_queue; ircbot->send = irc_send; ircbot->relay = irc_relay; ircbot->pong = irc_pong; ircbot->privmsg = irc_privmsg; + ircbot->privmsg_ctcp = irc_privmsg_ctcp; ircbot->userjoin = irc_userjoin; ircbot->userleave = irc_userleave; diff --git a/src/map/irc-bot.h b/src/map/irc-bot.h index dc67e2fe8..54f462e35 100644 --- a/src/map/irc-bot.h +++ b/src/map/irc-bot.h @@ -39,6 +39,11 @@ struct irc_func { void (*func)(int, char*, char*, char*, char*); }; +struct message_flood { + char message[IRC_MESSAGE_LENGTH]; + struct message_flood *next; +}; + struct irc_bot_interface { int fd; bool isIn, isOn; @@ -46,6 +51,15 @@ struct irc_bot_interface { unsigned char fails; uint32 ip; unsigned short port; + /* messages flood protection */ + bool flood_protection_enabled; + int flood_protection_rate; + int flood_protection_burst; + int64 last_message_tick; + int messages_burst_count; + int queue_tid; + struct message_flood *message_current; + struct message_flood *message_last; /* */ struct channel_data *channel; /* */ @@ -53,27 +67,132 @@ struct irc_bot_interface { struct irc_func **list; unsigned int size; } funcs; - /* */ + + /** + * IRC bot initializer + */ void (*init) (bool minimal); + + /** + * IRC bot finalizer + */ void (*final) (void); - /* */ + + /** + * Parser for the IRC server connection + * @see do_sockets + */ int (*parse) (int fd); + + /** + * Parse a received message from the irc server, and do the appropriate action + * for the detected command + * @param fd IRC server connection file descriptor + * @param str Raw received message + */ void (*parse_sub) (int fd, char *str); + + /** + * Parse the source from a received irc message + * @param source Source string, as reported by the server + * @param nick Pointer to a string where to return the nick (may not be NULL, + * needs to be able to fit an IRC_NICK_LENGTH long string) + * @param ident Pointer to a string where to return the ident (may not be + * NULL, needs to be able to fit an IRC_IDENT_LENGTH long string) + * @param host Pointer to a string where to return the hostname (may not be + * NULL, needs to be able to fit an IRC_HOST_LENGTH long string) + */ void (*parse_source) (char *source, char *nick, char *ident, char *host); - /* */ + + /** + * Search the handler for a given IRC received command + * @param function_name Name of the received IRC command + * @return Function pointer to the command handler, NULL in case + * of unhandled commands + */ struct irc_func* (*func_search) (char* function_name); - /* */ + + /** + * Timer callback to (re-)connect to an IRC server + * @see timer_interface::do_timer + */ int (*connect_timer) (int tid, int64 tick, int id, intptr_t data); + + /** + * Timer callback to send identification commands to an IRC server + * @see timer_interface::do_timer + */ int (*identify_timer) (int tid, int64 tick, int id, intptr_t data); + + /** + * Timer callback to join channels (and optionally send NickServ commands) + * @see timer_interface::do_timer + */ int (*join_timer) (int tid, int64 tick, int id, intptr_t data); - /* */ - void (*send)(char *str); + + /** + * Timer callback to send queued IRC Commands + * @see timer_interface::do_timer + */ + int (*queue_timer) (int tid, int64 tick, int id, intptr_t data); + + /** + * Decides if an IRC Command should be queued or not, based on the flood protection settings. + * + * @param str Command to be checked + */ + void (*queue) (char *str); + + /** + * Send a raw command to the irc server + * @param str Command to send + */ + void (*send)(char *str, bool force); + + /** + * Relay a chat message to the irc channel the bot is connected to + * @param name Sender's name + * @param msg Message text + */ void (*relay) (const char *name, const char *msg); - /* */ + + /** + * Handler for the PING IRC command (send back a PONG) + * @see irc_bot_interface::parse_sub + */ void (*pong) (int fd, char *cmd, char *source, char *target, char *msg); + + /** + * Handler for the PRIVMSG IRC command (action depends on the message contents) + * @see irc_bot_interface::parse_sub + */ void (*privmsg) (int fd, char *cmd, char *source, char *target, char *msg); + + /** + * Handler for CTCP commands received via PRIVMSG + * @see irc_bot_interface::privmsg + */ + void (*privmsg_ctcp) (int fd, char *cmd, char *source, char *target, char *msg); + + /** + * Handler for the JOIN IRC command (notify an in-game channel of users joining + * the IRC channel) + * @see irc_bot_interface::parse_sub + */ void (*userjoin) (int fd, char *cmd, char *source, char *target, char *msg); + + /** + * Handler for the PART and QUIT IRC commands (notify an in-game channel of + * users leaving the IRC channel) + * @see irc_bot_interface::parse_sub + */ void (*userleave) (int fd, char *cmd, char *source, char *target, char *msg); + + /** + * Handler for the NICK IRC commands (notify an in-game channel of users + * changing their name while in the IRC channel) + * @see irc_bot_interface::parse_sub + */ void (*usernick) (int fd, char *cmd, char *source, char *target, char *msg); }; diff --git a/src/map/itemdb.c b/src/map/itemdb.c index c59f627cc..350697a08 100644 --- a/src/map/itemdb.c +++ b/src/map/itemdb.c @@ -342,7 +342,7 @@ const char* itemdb_typename(int type) return "Unknown Type"; } - /** +/** * Converts the JobID to the format used by map-server to check item * restriction as per job. * @@ -1658,7 +1658,7 @@ int itemdb_validate_entry(struct item_data *entry, int n, const char *source) { void itemdb_readdb_additional_fields(int itemid, struct config_setting_t *it, int n, const char *source) { - // do nothing. plugins can do own work + // do nothing. plugins can do own work } /** diff --git a/src/map/map.c b/src/map/map.c index 3a7d752c3..30c849ed1 100644 --- a/src/map/map.c +++ b/src/map/map.c @@ -6002,22 +6002,6 @@ static CMDLINEARG(loadscript) } /** - * --generate-translations - * - * Creates "./generated_translations.pot" - * @see cmdline->exec - **/ -static CMDLINEARG(generatetranslations) { - script->lang_export_file = aStrdup("./generated_translations.pot"); - - if( !(script->lang_export_fp = fopen(script->lang_export_file,"wb")) ) { - ShowError("export-dialog: failed to open '%s' for writing\n",script->lang_export_file); - } - core->runflag = CORE_ST_STOP; - return true; -} - -/** * Defines the local command line arguments */ void cmdline_args_init_local(void) @@ -6033,7 +6017,6 @@ void cmdline_args_init_local(void) CMDLINEARG_DEF2(log-config, logconfig, "Alternative logging configuration.", CMDLINE_OPT_NORMAL|CMDLINE_OPT_PARAM); CMDLINEARG_DEF2(script-check, scriptcheck, "Doesn't run the server, only tests the scripts passed through --load-script.", CMDLINE_OPT_SILENT); CMDLINEARG_DEF2(load-script, loadscript, "Loads an additional script (can be repeated).", CMDLINE_OPT_NORMAL|CMDLINE_OPT_PARAM); - CMDLINEARG_DEF2(generate-translations, generatetranslations, "Creates './generated_translations.pot' file with all translateable strings from scripts, server terminates afterwards.", CMDLINE_OPT_NORMAL); } int do_init(int argc, char *argv[]) @@ -6079,7 +6062,9 @@ int do_init(int argc, char *argv[]) char ip_str[16]; sockt->ip2str(sockt->addr_[0], ip_str); +#ifndef BUILDBOT ShowWarning("Not all IP addresses in /conf/map-server.conf configured, auto-detecting...\n"); +#endif if (sockt->naddr_ == 0) ShowError("Unable to determine your IP address...\n"); diff --git a/src/map/mob.c b/src/map/mob.c index c765e7d63..b6b36dd61 100644 --- a/src/map/mob.c +++ b/src/map/mob.c @@ -421,7 +421,7 @@ bool mob_ksprotected(struct block_list *src, struct block_list *target) { if( DIFF_TICK(sd->ks_floodprotect_tick, tick) <= 0 ) { sprintf(output, "[KS Warning!! - Owner : %s]", pl_sd->status.name); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); sd->ks_floodprotect_tick = tick + 2000; } @@ -430,7 +430,7 @@ bool mob_ksprotected(struct block_list *src, struct block_list *target) { if( DIFF_TICK(pl_sd->ks_floodprotect_tick, tick) <= 0 ) { sprintf(output, "[Watch out! %s is trying to KS you!]", sd->status.name); - clif_disp_onlyself(pl_sd, output, strlen(output)); + clif_disp_onlyself(pl_sd, output); pl_sd->ks_floodprotect_tick = tick + 2000; } @@ -2337,11 +2337,6 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type) { if(flag) { if(base_exp || job_exp) { if( md->dmglog[i].flag != MDLF_PET || battle_config.pet_attack_exp_to_master ) { -#ifdef RENEWAL_EXP - int rate = pc->level_penalty_mod(md->level - (tmpsd[i])->status.base_level, md->status.race, md->status.mode, 1); - base_exp = (unsigned int)cap_value(base_exp * rate / 100, 1, UINT_MAX); - job_exp = (unsigned int)cap_value(job_exp * rate / 100, 1, UINT_MAX); -#endif pc->gainexp(tmpsd[i], &md->bl, base_exp, job_exp, false); } } @@ -2447,7 +2442,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type) { char message[128]; sprintf (message, msg_txt(541), mvp_sd->status.name, md->name, it->jname, (float)drop_rate/100); //MSG: "'%s' won %s's %s (chance: %0.02f%%)" - intif->broadcast(message, strlen(message)+1, BC_DEFAULT); + intif->broadcast(message, (int)strlen(message)+1, BC_DEFAULT); } /* heres the thing we got the feature set up however we're still discussing how to best define the ids, @@ -2556,60 +2551,62 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type) { pc->gainexp(mvp_sd, &md->bl, mexp,0, false); log_mvp[1] = mexp; - if( !(map->list[m].flag.nomvploot || type&1) ) { + if (!(map->list[m].flag.nomvploot || type&1)) { /* pose them randomly in the list -- so on 100% drop servers it wont always drop the same item */ - int mdrop_id[MAX_MVP_DROP]; - int mdrop_p[MAX_MVP_DROP]; - struct item item; - - memset(&mdrop_id,0,MAX_MVP_DROP*sizeof(int)); - - for(i = 0; i < MAX_MVP_DROP; i++) { - while( 1 ) { - int va = rnd()%MAX_MVP_DROP; - if( !mdrop_id[va] || !md->db->mvpitem[i].nameid ) { - mdrop_id[va] = md->db->mvpitem[i].nameid; - mdrop_p[va] = md->db->mvpitem[i].p; - break; - } - } + struct { + int nameid; + int p; + } mdrop[MAX_MVP_DROP] = { { 0 } }; + + for (i = 0; i < MAX_MVP_DROP; i++) { + int rpos; + if (md->db->mvpitem[i].nameid == 0) + continue; + do { + rpos = rnd()%MAX_MVP_DROP; + } while (mdrop[rpos].nameid != 0); + + mdrop[rpos].nameid = md->db->mvpitem[i].nameid; + mdrop[rpos].p = md->db->mvpitem[i].p; } - for(i = 0; i < MAX_MVP_DROP; i++) { - struct item_data *data; - if(mdrop_id[i] <= 0) + for (i = 0; i < MAX_MVP_DROP; i++) { + struct item_data *data = NULL; + int rate = 0; + + if (mdrop[i].nameid <= 0) continue; - if(! (data = itemdb->exists(mdrop_id[i])) ) + if ((data = itemdb->exists(mdrop[i].nameid)) == NULL) continue; - temp = mdrop_p[i]; - if(temp <= 0 && !battle_config.drop_rate0item) - temp = 1; - if(temp <= rnd()%10000+1) //if ==0, then it doesn't drop - continue; + rate = mdrop[i].p; + if (rate <= 0 && !battle_config.drop_rate0item) + rate = 1; + if (rate > rnd()%10000) { + struct item item = { 0 }; + + item.nameid = mdrop[i].nameid; + item.identify = itemdb->isidentified2(data); + clif->mvp_item(mvp_sd, item.nameid); + log_mvp[0] = item.nameid; + + //A Rare MVP Drop Global Announce by Lupus + if (rate <= battle_config.rare_drop_announce) { + char message[128]; + sprintf(message, msg_txt(541), mvp_sd->status.name, md->name, data->jname, rate/100.); + //MSG: "'%s' won %s's %s (chance: %0.02f%%)" + intif->broadcast(message, (int)strlen(message)+1, BC_DEFAULT); + } - memset(&item,0,sizeof(item)); - item.nameid=mdrop_id[i]; - item.identify= itemdb->isidentified2(data); - clif->mvp_item(mvp_sd,item.nameid); - log_mvp[0] = item.nameid; - - //A Rare MVP Drop Global Announce by Lupus - if(temp<=battle_config.rare_drop_announce) { - char message[128]; - sprintf (message, msg_txt(541), mvp_sd->status.name, md->name, data->jname, temp/100.); - //MSG: "'%s' won %s's %s (chance: %0.02f%%)" - intif->broadcast(message, strlen(message)+1, BC_DEFAULT); - } + if((temp = pc->additem(mvp_sd,&item,1,LOG_TYPE_PICKDROP_PLAYER)) != 0) { + clif->additem(mvp_sd,0,0,temp); + map->addflooritem(&md->bl, &item, 1, mvp_sd->bl.m, mvp_sd->bl.x, mvp_sd->bl.y, mvp_sd->status.char_id, (second_sd?second_sd->status.char_id : 0), (third_sd ? third_sd->status.char_id : 0), 1); + } - if((temp = pc->additem(mvp_sd,&item,1,LOG_TYPE_PICKDROP_PLAYER)) != 0) { - clif->additem(mvp_sd,0,0,temp); - map->addflooritem(&md->bl, &item, 1, mvp_sd->bl.m, mvp_sd->bl.x, mvp_sd->bl.y, mvp_sd->status.char_id, (second_sd?second_sd->status.char_id : 0), (third_sd ? third_sd->status.char_id : 0), 1); + //Logs items, MVP prizes [Lupus] + logs->pick_mob(md, LOG_TYPE_MVP, -1, &item, data); + break; } - - //Logs items, MVP prizes [Lupus] - logs->pick_mob(md, LOG_TYPE_MVP, -1, &item, data); - break; } } diff --git a/src/map/npc.c b/src/map/npc.c index 1b784b0c8..945a84957 100644 --- a/src/map/npc.c +++ b/src/map/npc.c @@ -62,17 +62,6 @@ struct npc_interface npc_s; struct npc_interface *npc; -static int npc_id=START_NPC_NUM; -static int npc_warp=0; -static int npc_shop=0; -static int npc_script=0; -static int npc_mob=0; -static int npc_delay_mob=0; -static int npc_cache_mob=0; - -static const char *npc_last_path; -static const char *npc_last_ref; -struct npc_path_data *npc_last_npd; //For holding the view data of npc classes. [Skotlex] static struct view_data npc_viewdb[MAX_NPC_CLASS]; @@ -132,15 +121,15 @@ bool npc_db_checkid(int id) /// Returns a new npc id that isn't being used in id_db. /// Fatal error if nothing is available. int npc_get_new_npc_id(void) { - if( npc_id >= START_NPC_NUM && !map->blid_exists(npc_id) ) - return npc_id++;// available + if (npc->npc_id >= START_NPC_NUM && !map->blid_exists(npc->npc_id)) + return npc->npc_id++;// available else {// find next id - int base_id = npc_id; - while( base_id != ++npc_id ) { - if( npc_id < START_NPC_NUM ) - npc_id = START_NPC_NUM; - if( !map->blid_exists(npc_id) ) - return npc_id++;// available + int base_id = npc->npc_id; + while (base_id != ++npc->npc_id) { + if (npc->npc_id < START_NPC_NUM) + npc->npc_id = START_NPC_NUM; + if (!map->blid_exists(npc->npc_id)) + return npc->npc_id++;// available } // full loop, nothing available ShowFatalError("npc_get_new_npc_id: All ids are taken. Exiting..."); @@ -2509,10 +2498,10 @@ const char *npc_retainpathreference(const char *filepath) struct npc_path_data * npd = NULL; nullpo_ret(filepath); - if (npc_last_path == filepath) { - if (npc_last_npd != NULL) - npc_last_npd->references++; - return npc_last_ref; + if (npc->npc_last_path == filepath) { + if (npc->npc_last_npd != NULL) + npc->npc_last_npd->references++; + return npc->npc_last_ref; } if ((npd = strdb_get(npc->path_db,filepath)) == NULL) { @@ -2527,9 +2516,9 @@ const char *npc_retainpathreference(const char *filepath) npd->references++; - npc_last_npd = npd; - npc_last_ref = npd->path; - npc_last_path = filepath; + npc->npc_last_npd = npd; + npc->npc_last_ref = npd->path; + npc->npc_last_path = filepath; return npd->path; } @@ -2545,7 +2534,7 @@ void npc_releasepathreference(const char *filepath) nullpo_retv(filepath); - if (filepath != npc_last_ref) { + if (filepath != npc->npc_last_ref) { npd = strdb_get(npc->path_db, filepath); } @@ -2785,7 +2774,7 @@ const char *npc_parse_warp(const char *w1, const char *w2, const char *w3, const nd->u.warp.y = to_y; nd->u.warp.xs = xs; nd->u.warp.ys = ys; - npc_warp++; + npc->npc_warp++; npc->add_to_location(nd); @@ -2930,7 +2919,7 @@ const char *npc_parse_shop(const char *w1, const char *w2, const char *w3, const npc->parsename(nd, w3, start, buffer, filepath); nd->path = npc->retainpathreference(filepath); - ++npc_shop; + ++npc->npc_shop; npc->add_to_location(nd); return strchr(start,'\n');// continue @@ -3136,7 +3125,7 @@ const char *npc_parse_script(const char *w1, const char *w2, const char *w3, con if( options&NPO_TRADER ) nd->u.scr.trader = true; nd->u.scr.shop = NULL; - ++npc_script; + ++npc->npc_script; npc->add_to_location(nd); //----------------------------------------- @@ -3206,7 +3195,7 @@ bool npc_duplicate_script_sub(struct npc_data *nd, const struct npc_data *snd, i nullpo_retr(false, nd); nullpo_retr(false, snd); - ++npc_script; + ++npc->npc_script; nd->u.scr.xs = xs; nd->u.scr.ys = ys; nd->u.scr.script = snd->u.scr.script; @@ -3253,7 +3242,7 @@ bool npc_duplicate_shop_sub(struct npc_data *nd, const struct npc_data *snd, int nullpo_retr(false, nd); nullpo_retr(false, snd); - ++npc_shop; + ++npc->npc_shop; nd->u.shop.shop_item = snd->u.shop.shop_item; nd->u.shop.count = snd->u.shop.count; @@ -3271,7 +3260,7 @@ bool npc_duplicate_warp_sub(struct npc_data *nd, const struct npc_data *snd, int nullpo_retr(false, nd); nullpo_retr(false, snd); - ++npc_warp; + ++npc->npc_warp; nd->u.warp.xs = xs; nd->u.warp.ys = ys; nd->u.warp.mapindex = snd->u.warp.mapindex; @@ -3770,7 +3759,7 @@ const char *npc_parse_function(const char *w1, const char *w2, const char *w3, c struct script_code *oldscript = (struct script_code*)DB->data2ptr(&old_data); ShowWarning("npc_parse_function: Overwriting user function [%s] in file '%s', line '%d'.\n", w3, filepath, strline(buffer,start-buffer)); script->free_vars(oldscript->local.vars); - aFree(oldscript->script_buf); + VECTOR_CLEAR(oldscript->script_buf); aFree(oldscript); } @@ -3967,7 +3956,7 @@ const char *npc_parse_mob(const char *w1, const char *w2, const char *w3, const // spawn / cache the new mobs if( battle_config.dynamic_mobs && map->addmobtolist(data->m, data) >= 0 ) { data->state.dynamic = true; - npc_cache_mob += data->num; + npc->npc_cache_mob += data->num; // check if target map has players // (usually shouldn't occur when map server is just starting, @@ -3978,10 +3967,10 @@ const char *npc_parse_mob(const char *w1, const char *w2, const char *w3, const } else { data->state.dynamic = false; npc->parse_mob2(data); - npc_delay_mob += data->num; + npc->npc_delay_mob += data->num; } - npc_mob++; + npc->npc_mob++; return strchr(start,'\n');// continue } @@ -4778,12 +4767,12 @@ void npc_process_files( int npc_min ) { "\t-'"CL_WHITE"%d"CL_RESET"' Spawn sets\n" "\t-'"CL_WHITE"%d"CL_RESET"' Mobs Cached\n" "\t-'"CL_WHITE"%d"CL_RESET"' Mobs Not Cached\n", - npc_id - npc_min, npc_warp, npc_shop, npc_script, npc_mob, npc_cache_mob, npc_delay_mob); + npc->npc_id - npc_min, npc->npc_warp, npc->npc_shop, npc->npc_script, npc->npc_mob, npc->npc_cache_mob, npc->npc_delay_mob); } //Clear then reload npcs files int npc_reload(void) { - int npc_new_min = npc_id; + int npc_new_min = npc->npc_id; struct s_mapiterator* iter; struct block_list* bl; @@ -4799,9 +4788,9 @@ int npc_reload(void) { db_clear(npc->ev_db); npc->ev_label_db->clear(npc->ev_label_db, npc->ev_label_db_clear_sub); - npc_last_npd = NULL; - npc_last_path = NULL; - npc_last_ref = NULL; + npc->npc_last_npd = NULL; + npc->npc_last_path = NULL; + npc->npc_last_ref = NULL; //Remove all npcs/mobs. [Skotlex] iter = mapit_geteachiddb(); @@ -4841,8 +4830,8 @@ int npc_reload(void) { // clear mob spawn lookup index mob->clear_spawninfo(); - npc_warp = npc_shop = npc_script = 0; - npc_mob = npc_cache_mob = npc_delay_mob = 0; + npc->npc_warp = npc->npc_shop = npc->npc_script = 0; + npc->npc_mob = npc->npc_cache_mob = npc->npc_delay_mob = 0; // reset mapflags map->flags_init(); @@ -4965,14 +4954,8 @@ static void npc_debug_warps(void) { int do_init_npc(bool minimal) { int i; - memset(&npc->base_ud, 0, sizeof( struct unit_data) ); - npc->base_ud.bl = NULL; - npc->base_ud.walktimer = INVALID_TIMER; - npc->base_ud.skilltimer = INVALID_TIMER; - npc->base_ud.attacktimer = INVALID_TIMER; - npc->base_ud.attackabletime = - npc->base_ud.canact_tick = - npc->base_ud.canmove_tick = timer->gettick(); + unit->init_ud(&npc->base_ud); + npc->base_ud.bl = NULL; //Stock view data for normal npcs. memset(&npc_viewdb, 0, sizeof(npc_viewdb)); @@ -4988,9 +4971,9 @@ int do_init_npc(bool minimal) { npc->name_db = strdb_alloc(DB_OPT_BASE, NAME_LENGTH); npc->path_db = strdb_alloc(DB_OPT_DUP_KEY|DB_OPT_RELEASE_DATA, 0); - npc_last_npd = NULL; - npc_last_path = NULL; - npc_last_ref = NULL; + npc->npc_last_npd = NULL; + npc->npc_last_path = NULL; + npc->npc_last_ref = NULL; // Should be loaded before npc processing, otherwise labels could overwrite constant values // and lead to undefined behavior [Panikon] @@ -5019,12 +5002,6 @@ int do_init_npc(bool minimal) { timer->add_func_list(npc->timerevent,"npc_timerevent"); } - if( script->lang_export_fp ) { - ShowInfo("Lang exported to '%s'\n",script->lang_export_file); - fclose(script->lang_export_fp); - script->lang_export_fp = NULL; - } - // Init dummy NPC CREATE(npc->fake_nd, struct npc_data, 1); npc->fake_nd->bl.m = -1; @@ -5034,7 +5011,7 @@ int do_init_npc(bool minimal) { strcpy(npc->fake_nd->name,"FAKE_NPC"); memcpy(npc->fake_nd->exname, npc->fake_nd->name, 9); - npc_script++; + npc->npc_script++; npc->fake_nd->bl.type = BL_NPC; npc->fake_nd->subtype = SCRIPT; @@ -5048,6 +5025,17 @@ int do_init_npc(bool minimal) { void npc_defaults(void) { npc = &npc_s; + npc->npc_id = START_NPC_NUM; + npc->npc_warp = 0; + npc->npc_shop = 0; + npc->npc_script = 0; + npc->npc_mob = 0; + npc->npc_delay_mob = 0; + npc->npc_cache_mob = 0; + npc->npc_last_path = NULL; + npc->npc_last_ref = NULL; + npc->npc_last_npd = NULL; + npc->motd = NULL; npc->ev_db = NULL; npc->ev_label_db = NULL; diff --git a/src/map/npc.h b/src/map/npc.h index 8ee59e410..24ea9ea59 100644 --- a/src/map/npc.h +++ b/src/map/npc.h @@ -188,6 +188,16 @@ struct npc_interface { /* npc trader global data, for ease of transition between the script, cleared on every usage */ bool trader_ok; int trader_funds[2]; + int npc_id; + int npc_warp; + int npc_shop; + int npc_script; + int npc_mob; + int npc_delay_mob; + int npc_cache_mob; + const char *npc_last_path; + const char *npc_last_ref; + struct npc_path_data *npc_last_npd; /* */ int (*init) (bool minimal); int (*final) (void); diff --git a/src/map/npc_chat.c b/src/map/npc_chat.c index 6726c65a9..4bd7d416d 100644 --- a/src/map/npc_chat.c +++ b/src/map/npc_chat.c @@ -100,6 +100,7 @@ struct pcre_interface *libpcre; */ void finalize_pcrematch_entry(struct pcrematch_entry* e) { + nullpo_retv(e); libpcre->free(e->pcre_); libpcre->free(e->pcre_extra_); aFree(e->pattern); @@ -111,7 +112,10 @@ void finalize_pcrematch_entry(struct pcrematch_entry* e) */ struct pcrematch_set* lookup_pcreset(struct npc_data* nd, int setid) { struct pcrematch_set *pcreset; - struct npc_parse *npcParse = nd->chatdb; + struct npc_parse *npcParse; + + nullpo_retr(NULL, nd); + npcParse = nd->chatdb; if (npcParse == NULL) nd->chatdb = npcParse = (struct npc_parse *)aCalloc(sizeof(struct npc_parse), 1); @@ -151,7 +155,9 @@ struct pcrematch_set* lookup_pcreset(struct npc_data* nd, int setid) { void activate_pcreset(struct npc_data* nd, int setid) { struct pcrematch_set *pcreset; - struct npc_parse *npcParse = nd->chatdb; + struct npc_parse *npcParse; + nullpo_retv(nd); + npcParse = nd->chatdb; if (npcParse == NULL) return; // Nothing to activate... pcreset = npcParse->inactive; @@ -184,7 +190,9 @@ void activate_pcreset(struct npc_data* nd, int setid) void deactivate_pcreset(struct npc_data* nd, int setid) { struct pcrematch_set *pcreset; - struct npc_parse *npcParse = nd->chatdb; + struct npc_parse *npcParse; + nullpo_retv(nd); + npcParse = nd->chatdb; if (npcParse == NULL) return; // Nothing to deactivate... if (setid == -1) { @@ -221,7 +229,9 @@ void delete_pcreset(struct npc_data* nd, int setid) { int active = 1; struct pcrematch_set *pcreset; - struct npc_parse *npcParse = nd->chatdb; + struct npc_parse *npcParse; + nullpo_retv(nd); + npcParse = nd->chatdb; if (npcParse == NULL) return; // Nothing to deactivate... pcreset = npcParse->active; @@ -269,8 +279,12 @@ void delete_pcreset(struct npc_data* nd, int setid) */ struct pcrematch_entry* create_pcrematch_entry(struct pcrematch_set* set) { - struct pcrematch_entry * e = (struct pcrematch_entry *) aCalloc(sizeof(struct pcrematch_entry), 1); - struct pcrematch_entry * last = set->head; + struct pcrematch_entry *e; + struct pcrematch_entry *last; + + nullpo_retr(NULL, set); + e = (struct pcrematch_entry *)aCalloc(sizeof(struct pcrematch_entry), 1); + last = set->head; // Normally we would have just stuck it at the end of the list but // this doesn't sink up with peoples usage pattern. They wanted @@ -303,6 +317,7 @@ void npc_chat_def_pattern(struct npc_data* nd, int setid, const char* pattern, c struct pcrematch_set * s = npc_chat->lookup_pcreset(nd, setid); struct pcrematch_entry *e = npc_chat->create_pcrematch_entry(s); + nullpo_retv(e); e->pattern = aStrdup(pattern); e->label = aStrdup(label); e->pcre_ = libpcre->compile(pattern, PCRE_CASELESS, &err, &erroff, NULL); @@ -317,7 +332,10 @@ void npc_chat_def_pattern(struct npc_data* nd, int setid, const char* pattern, c */ void npc_chat_finalize(struct npc_data* nd) { - struct npc_parse *npcParse = nd->chatdb; + struct npc_parse *npcParse; + + nullpo_retv(nd); + npcParse = nd->chatdb; if (npcParse == NULL) return; @@ -358,6 +376,8 @@ int npc_chat_sub(struct block_list* bl, va_list ap) len = va_arg(ap,int); sd = va_arg(ap,struct map_session_data *); + nullpo_ret(sd); + // iterate across all active sets for (pcreset = npcParse->active; pcreset != NULL; pcreset = pcreset->next) { @@ -373,7 +393,7 @@ int npc_chat_sub(struct block_list* bl, va_list ap) // save out the matched strings for (i = 0; i < r; i++) { - char var[6], val[255]; + char var[12], val[255]; snprintf(var, sizeof(var), "$@p%i$", i); libpcre->copy_substring(msg, offsets, r, i, val, sizeof(val)); script->set_var(sd, var, val); diff --git a/src/map/packets_struct.h b/src/map/packets_struct.h index 25b20cddf..e461eebe9 100644 --- a/src/map/packets_struct.h +++ b/src/map/packets_struct.h @@ -312,134 +312,134 @@ enum packet_headers { * structs for data */ struct EQUIPSLOTINFO { - unsigned short card[4]; + uint16 card[4]; } __attribute__((packed)); struct NORMALITEM_INFO { - short index; - unsigned short ITID; - unsigned char type; + int16 index; + uint16 ITID; + uint8 type; #if PACKETVER < 20120925 uint8 IsIdentified; #endif - short count; + int16 count; #if PACKETVER >= 20120925 - unsigned int WearState; + uint32 WearState; #else - unsigned short WearState; + uint16 WearState; #endif #if PACKETVER >= 5 struct EQUIPSLOTINFO slot; #endif #if PACKETVER >= 20080102 - int HireExpireDate; + int32 HireExpireDate; #endif #if PACKETVER >= 20120925 struct { - unsigned char IsIdentified : 1; - unsigned char PlaceETCTab : 1; - unsigned char SpareBits : 6; + uint8 IsIdentified : 1; + uint8 PlaceETCTab : 1; + uint8 SpareBits : 6; } Flag; #endif } __attribute__((packed)); struct RndOptions { - short index; - short value; - unsigned char param; + int16 index; + int16 value; + uint8 param; } __attribute__((packed)); struct EQUIPITEM_INFO { - short index; - unsigned short ITID; - unsigned char type; + int16 index; + uint16 ITID; + uint8 type; #if PACKETVER < 20120925 uint8 IsIdentified; #endif #if PACKETVER >= 20120925 - unsigned int location; - unsigned int WearState; + uint32 location; + uint32 WearState; #else - unsigned short location; - unsigned short WearState; + uint16 location; + uint16 WearState; #endif #if PACKETVER < 20120925 uint8 IsDamaged; #endif - unsigned char RefiningLevel; + uint8 RefiningLevel; struct EQUIPSLOTINFO slot; #if PACKETVER >= 20071002 - int HireExpireDate; + int32 HireExpireDate; #endif #if PACKETVER >= 20080102 - unsigned short bindOnEquipType; + uint16 bindOnEquipType; #endif #if PACKETVER >= 20100629 - unsigned short wItemSpriteNumber; + uint16 wItemSpriteNumber; #endif #if PACKETVER >= 20150226 - unsigned char option_count; + uint8 option_count; struct RndOptions option_data[5]; #endif #if PACKETVER >= 20120925 struct { - unsigned char IsIdentified : 1; - unsigned char IsDamaged : 1; - unsigned char PlaceETCTab : 1; - unsigned char SpareBits : 5; + uint8 IsIdentified : 1; + uint8 IsDamaged : 1; + uint8 PlaceETCTab : 1; + uint8 SpareBits : 5; } Flag; #endif } __attribute__((packed)); struct packet_authok { - short PacketType; - unsigned int startTime; - unsigned char PosDir[3]; - unsigned char xSize; - unsigned char ySize; + int16 PacketType; + uint32 startTime; + uint8 PosDir[3]; + uint8 xSize; + uint8 ySize; #if PACKETVER >= 20080102 - short font; + int16 font; #endif #if PACKETVER >= 20141022 - unsigned char sex; + uint8 sex; #endif } __attribute__((packed)); struct packet_monster_hp { - short PacketType; - unsigned int GID; - int HP; - int MaxHP; + int16 PacketType; + uint32 GID; + int32 HP; + int32 MaxHP; } __attribute__((packed)); struct packet_sc_notick { - short PacketType; - short index; - unsigned int AID; - unsigned char state; + int16 PacketType; + int16 index; + uint32 AID; + uint8 state; } __attribute__((packed)); struct packet_additem { - short PacketType; - unsigned short Index; - unsigned short count; - unsigned short nameid; + int16 PacketType; + uint16 Index; + uint16 count; + uint16 nameid; uint8 IsIdentified; uint8 IsDamaged; - unsigned char refiningLevel; + uint8 refiningLevel; struct EQUIPSLOTINFO slot; #if PACKETVER >= 20120925 - unsigned int location; + uint32 location; #else - unsigned short location; + uint16 location; #endif - unsigned char type; - unsigned char result; + uint8 type; + uint8 result; #if PACKETVER >= 20061218 - int HireExpireDate; + int32 HireExpireDate; #endif #if PACKETVER >= 20071002 - unsigned short bindOnEquipType; + uint16 bindOnEquipType; #endif #if PACKETVER >= 20150226 struct RndOptions option_data[5]; @@ -447,51 +447,51 @@ struct packet_additem { } __attribute__((packed)); struct packet_dropflooritem { - short PacketType; - unsigned int ITAID; - unsigned short ITID; + int16 PacketType; + uint32 ITAID; + uint16 ITID; #if PACKETVER >= 20130000 /* not sure date */ - unsigned short type; + uint16 type; #endif uint8 IsIdentified; - short xPos; - short yPos; - unsigned char subX; - unsigned char subY; - short count; + int16 xPos; + int16 yPos; + uint8 subX; + uint8 subY; + int16 count; } __attribute__((packed)); struct packet_idle_unit2 { #if PACKETVER < 20091103 - short PacketType; + int16 PacketType; #if PACKETVER >= 20071106 - unsigned char objecttype; -#endif - unsigned int GID; - short speed; - short bodyState; - short healthState; - short effectState; - short job; - short head; - short weapon; - short accessory; - short shield; - short accessory2; - short accessory3; - short headpalette; - short bodypalette; - short headDir; - unsigned int GUID; - short GEmblemVer; - short honor; - short virtue; + uint8 objecttype; +#endif + uint32 GID; + int16 speed; + int16 bodyState; + int16 healthState; + int16 effectState; + int16 job; + int16 head; + int16 weapon; + int16 accessory; + int16 shield; + int16 accessory2; + int16 accessory3; + int16 headpalette; + int16 bodypalette; + int16 headDir; + uint32 GUID; + int16 GEmblemVer; + int16 honor; + int16 virtue; uint8 isPKModeON; - unsigned char sex; - unsigned char PosDir[3]; - unsigned char xSize; - unsigned char ySize; - unsigned char state; - short clevel; + uint8 sex; + uint8 PosDir[3]; + uint8 xSize; + uint8 ySize; + uint8 state; + int16 clevel; #else // ! PACKETVER < 20091103 UNAVAILABLE_STRUCT; #endif // PACKETVER < 20091103 @@ -499,473 +499,473 @@ struct packet_idle_unit2 { struct packet_spawn_unit2 { #if PACKETVER < 20091103 - short PacketType; + int16 PacketType; #if PACKETVER >= 20071106 - unsigned char objecttype; -#endif - unsigned int GID; - short speed; - short bodyState; - short healthState; - short effectState; - short head; - short weapon; - short accessory; - short job; - short shield; - short accessory2; - short accessory3; - short headpalette; - short bodypalette; - short headDir; + uint8 objecttype; +#endif + uint32 GID; + int16 speed; + int16 bodyState; + int16 healthState; + int16 effectState; + int16 head; + int16 weapon; + int16 accessory; + int16 job; + int16 shield; + int16 accessory2; + int16 accessory3; + int16 headpalette; + int16 bodypalette; + int16 headDir; uint8 isPKModeON; - unsigned char sex; - unsigned char PosDir[3]; - unsigned char xSize; - unsigned char ySize; + uint8 sex; + uint8 PosDir[3]; + uint8 xSize; + uint8 ySize; #else // ! PACKETVER < 20091103 UNAVAILABLE_STRUCT; #endif // PACKETVER < 20091103 } __attribute__((packed)); struct packet_spawn_unit { - short PacketType; + int16 PacketType; #if PACKETVER >= 20091103 - short PacketLength; - unsigned char objecttype; + int16 PacketLength; + uint8 objecttype; #endif #if PACKETVER >= 20131223 - unsigned int AID; + uint32 AID; #endif - unsigned int GID; - short speed; - short bodyState; - short healthState; + uint32 GID; + int16 speed; + int16 bodyState; + int16 healthState; #if PACKETVER < 20080102 - short effectState; + int16 effectState; #else - int effectState; + int32 effectState; #endif - short job; - short head; + int16 job; + int16 head; #if PACKETVER < 7 - short weapon; + int16 weapon; #else - int weapon; + int32 weapon; #endif - short accessory; + int16 accessory; #if PACKETVER < 7 - short shield; + int16 shield; #endif - short accessory2; - short accessory3; - short headpalette; - short bodypalette; - short headDir; + int16 accessory2; + int16 accessory3; + int16 headpalette; + int16 bodypalette; + int16 headDir; #if PACKETVER >= 20101124 - short robe; + int16 robe; #endif - unsigned int GUID; - short GEmblemVer; - short honor; + uint32 GUID; + int16 GEmblemVer; + int16 honor; #if PACKETVER > 7 - int virtue; + int32 virtue; #else - short virtue; + int16 virtue; #endif uint8 isPKModeON; - unsigned char sex; - unsigned char PosDir[3]; - unsigned char xSize; - unsigned char ySize; - short clevel; + uint8 sex; + uint8 PosDir[3]; + uint8 xSize; + uint8 ySize; + int16 clevel; #if PACKETVER >= 20080102 - short font; + int16 font; #endif #if PACKETVER >= 20120221 - int maxHP; - int HP; - unsigned char isBoss; + int32 maxHP; + int32 HP; + uint8 isBoss; #endif #if PACKETVER >= 20150513 - short body; + int16 body; char name[NAME_LENGTH]; #endif } __attribute__((packed)); struct packet_unit_walking { - short PacketType; + int16 PacketType; #if PACKETVER >= 20091103 - short PacketLength; + int16 PacketLength; #endif #if PACKETVER > 20071106 - unsigned char objecttype; + uint8 objecttype; #endif #if PACKETVER >= 20131223 - unsigned int AID; + uint32 AID; #endif - unsigned int GID; - short speed; - short bodyState; - short healthState; + uint32 GID; + int16 speed; + int16 bodyState; + int16 healthState; #if PACKETVER < 7 - short effectState; + int16 effectState; #else - int effectState; + int32 effectState; #endif - short job; - short head; + int16 job; + int16 head; #if PACKETVER < 7 - short weapon; + int16 weapon; #else - int weapon; + int32 weapon; #endif - short accessory; - unsigned int moveStartTime; + int16 accessory; + uint32 moveStartTime; #if PACKETVER < 7 - short shield; + int16 shield; #endif - short accessory2; - short accessory3; - short headpalette; - short bodypalette; - short headDir; + int16 accessory2; + int16 accessory3; + int16 headpalette; + int16 bodypalette; + int16 headDir; #if PACKETVER >= 20101124 - short robe; + int16 robe; #endif - unsigned int GUID; - short GEmblemVer; - short honor; + uint32 GUID; + int16 GEmblemVer; + int16 honor; #if PACKETVER > 7 - int virtue; + int32 virtue; #else - short virtue; + int16 virtue; #endif uint8 isPKModeON; - unsigned char sex; - unsigned char MoveData[6]; - unsigned char xSize; - unsigned char ySize; - short clevel; + uint8 sex; + uint8 MoveData[6]; + uint8 xSize; + uint8 ySize; + int16 clevel; #if PACKETVER >= 20080102 - short font; + int16 font; #endif #if PACKETVER >= 20120221 - int maxHP; - int HP; - unsigned char isBoss; + int32 maxHP; + int32 HP; + uint8 isBoss; #endif #if PACKETVER >= 20150513 - short body; + int16 body; char name[NAME_LENGTH]; #endif } __attribute__((packed)); struct packet_idle_unit { - short PacketType; + int16 PacketType; #if PACKETVER >= 20091103 - short PacketLength; - unsigned char objecttype; + int16 PacketLength; + uint8 objecttype; #endif #if PACKETVER >= 20131223 - unsigned int AID; + uint32 AID; #endif - unsigned int GID; - short speed; - short bodyState; - short healthState; + uint32 GID; + int16 speed; + int16 bodyState; + int16 healthState; #if PACKETVER < 20080102 - short effectState; + int16 effectState; #else - int effectState; + int32 effectState; #endif - short job; - short head; + int16 job; + int16 head; #if PACKETVER < 7 - short weapon; + int16 weapon; #else - int weapon; + int32 weapon; #endif - short accessory; + int16 accessory; #if PACKETVER < 7 - short shield; + int16 shield; #endif - short accessory2; - short accessory3; - short headpalette; - short bodypalette; - short headDir; + int16 accessory2; + int16 accessory3; + int16 headpalette; + int16 bodypalette; + int16 headDir; #if PACKETVER >= 20101124 - short robe; + int16 robe; #endif - unsigned int GUID; - short GEmblemVer; - short honor; + uint32 GUID; + int16 GEmblemVer; + int16 honor; #if PACKETVER > 7 - int virtue; + int32 virtue; #else - short virtue; + int16 virtue; #endif uint8 isPKModeON; - unsigned char sex; - unsigned char PosDir[3]; - unsigned char xSize; - unsigned char ySize; - unsigned char state; - short clevel; + uint8 sex; + uint8 PosDir[3]; + uint8 xSize; + uint8 ySize; + uint8 state; + int16 clevel; #if PACKETVER >= 20080102 - short font; + int16 font; #endif #if PACKETVER >= 20120221 - int maxHP; - int HP; - unsigned char isBoss; + int32 maxHP; + int32 HP; + uint8 isBoss; #endif #if PACKETVER >= 20150513 - short body; + int16 body; char name[NAME_LENGTH]; #endif } __attribute__((packed)); struct packet_status_change { - short PacketType; - short index; - unsigned int AID; - unsigned char state; + int16 PacketType; + int16 index; + uint32 AID; + uint8 state; #if PACKETVER >= 20120618 - unsigned int Total; + uint32 Total; #endif #if PACKETVER >= 20090121 - unsigned int Left; - int val1; - int val2; - int val3; + uint32 Left; + int32 val1; + int32 val2; + int32 val3; #endif } __attribute__((packed)); struct packet_status_change_end { - short PacketType; - short index; - unsigned int AID; - unsigned char state; + int16 PacketType; + int16 index; + uint32 AID; + uint8 state; } __attribute__((packed)); struct packet_status_change2 { - short PacketType; - short index; - unsigned int AID; - unsigned char state; - unsigned int Left; - int val1; - int val2; - int val3; + int16 PacketType; + int16 index; + uint32 AID; + uint8 state; + uint32 Left; + int32 val1; + int32 val2; + int32 val3; } __attribute__((packed)); struct packet_maptypeproperty2 { - short PacketType; - short type; + int16 PacketType; + int16 type; struct { - unsigned int party : 1; // Show attack cursor on non-party members (PvP) - unsigned int guild : 1; // Show attack cursor on non-guild members (GvG) - unsigned int siege : 1; // Show emblem over characters' heads when in GvG (WoE castle) - unsigned int mineffect : 1; // Automatically enable /mineffect - unsigned int nolockon : 1; // TODO: What does this do? (shows attack cursor on non-party members) - unsigned int countpk : 1; /// Show the PvP counter - unsigned int nopartyformation : 1; /// Prevent party creation/modification - unsigned int bg : 1; // TODO: What does this do? Probably related to Battlegrounds, but I'm not sure on the effect - unsigned int nocostume : 1; /// Does not show costume sprite. - unsigned int usecart : 1; /// Allow opening cart inventory - unsigned int summonstarmiracle : 1; // TODO: What does this do? Related to Taekwon Masters, but I have no idea. - unsigned int SpareBits : 15; /// Currently ignored, reserved for future updates + uint32 party : 1; // Show attack cursor on non-party members (PvP) + uint32 guild : 1; // Show attack cursor on non-guild members (GvG) + uint32 siege : 1; // Show emblem over characters' heads when in GvG (WoE castle) + uint32 mineffect : 1; // Automatically enable /mineffect + uint32 nolockon : 1; // TODO: What does this do? (shows attack cursor on non-party members) + uint32 countpk : 1; /// Show the PvP counter + uint32 nopartyformation : 1; /// Prevent party creation/modification + uint32 bg : 1; // TODO: What does this do? Probably related to Battlegrounds, but I'm not sure on the effect + uint32 nocostume : 1; /// Does not show costume sprite. + uint32 usecart : 1; /// Allow opening cart inventory + uint32 summonstarmiracle : 1; // TODO: What does this do? Related to Taekwon Masters, but I have no idea. + uint32 SpareBits : 15; /// Currently ignored, reserved for future updates } flag; } __attribute__((packed)); struct packet_bgqueue_ack { - short PacketType; - unsigned char type; + int16 PacketType; + uint8 type; char bg_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_notice_delete { - short PacketType; - unsigned char type; + int16 PacketType; + uint8 type; char bg_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_register { - short PacketType; - short type; + int16 PacketType; + int16 type; char bg_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_update_info { - short PacketType; + int16 PacketType; char bg_name[NAME_LENGTH]; - int position; + int32 position; } __attribute__((packed)); struct packet_bgqueue_checkstate { - short PacketType; + int16 PacketType; char bg_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_revoke_req { - short PacketType; + int16 PacketType; char bg_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_battlebegin_ack { - short PacketType; - unsigned char result; + int16 PacketType; + uint8 result; char bg_name[NAME_LENGTH]; char game_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_bgqueue_notify_entry { - short PacketType; + int16 PacketType; char name[NAME_LENGTH]; - int position; + int32 position; } __attribute__((packed)); struct packet_bgqueue_battlebegins { - short PacketType; + int16 PacketType; char bg_name[NAME_LENGTH]; char game_name[NAME_LENGTH]; } __attribute__((packed)); struct packet_script_clear { - short PacketType; - unsigned int NpcID; + int16 PacketType; + uint32 NpcID; } __attribute__((packed)); /* made possible thanks to Yommy!! */ struct packet_package_item_announce { - short PacketType; - short PacketLength; - unsigned char type; - unsigned short ItemID; - char len; + int16 PacketType; + int16 PacketLength; + uint8 type; + uint16 ItemID; + int8 len; char Name[NAME_LENGTH]; - char unknown; - unsigned short BoxItemID; + int8 unknown; + uint16 BoxItemID; } __attribute__((packed)); /* made possible thanks to Yommy!! */ struct packet_item_drop_announce { - short PacketType; - short PacketLength; - unsigned char type; - unsigned short ItemID; - char len; + int16 PacketType; + int16 PacketLength; + uint8 type; + uint16 ItemID; + int8 len; char Name[NAME_LENGTH]; char monsterNameLen; char monsterName[NAME_LENGTH]; } __attribute__((packed)); struct packet_cart_additem_ack { - short PacketType; - char result; + int16 PacketType; + int8 result; } __attribute__((packed)); struct packet_banking_check { - short PacketType; + int16 PacketType; int64 Money; - short Reason; + int16 Reason; } __attribute__((packed)); struct packet_banking_deposit_req { - short PacketType; - unsigned int AID; - int Money; + int16 PacketType; + uint32 AID; + int32 Money; } __attribute__((packed)); struct packet_banking_withdraw_req { - short PacketType; - unsigned int AID; - int Money; + int16 PacketType; + uint32 AID; + int32 Money; } __attribute__((packed)); struct packet_banking_deposit_ack { - short PacketType; - short Reason; + int16 PacketType; + int16 Reason; int64 Money; - int Balance; + int32 Balance; } __attribute__((packed)); struct packet_banking_withdraw_ack { - short PacketType; - short Reason; + int16 PacketType; + int16 Reason; int64 Money; - int Balance; + int32 Balance; } __attribute__((packed)); /* Roulette System [Yommy/Hercules] */ struct packet_roulette_open_ack { - short PacketType; - char Result; - int Serial; - char Step; - char Idx; - short AdditionItemID; - int GoldPoint; - int SilverPoint; - int BronzePoint; + int16 PacketType; + int8 Result; + int32 Serial; + int8 Step; + int8 Idx; + int16 AdditionItemID; + int32 GoldPoint; + int32 SilverPoint; + int32 BronzePoint; } __attribute__((packed)); struct packet_roulette_info_ack { - short PacketType; - short PacketLength; - unsigned int RouletteSerial; + int16 PacketType; + int16 PacketLength; + uint32 RouletteSerial; struct { - unsigned short Row; - unsigned short Position; - unsigned short ItemId; - unsigned short Count; + uint16 Row; + uint16 Position; + uint16 ItemId; + uint16 Count; } ItemInfo[42]; } __attribute__((packed)); struct packet_roulette_close_ack { - short PacketType; - unsigned char Result; + int16 PacketType; + uint8 Result; } __attribute__((packed)); struct packet_roulette_generate_ack { - short PacketType; - unsigned char Result; - unsigned short Step; - unsigned short Idx; - unsigned short AdditionItemID; - int RemainGold; - int RemainSilver; - int RemainBronze; + int16 PacketType; + uint8 Result; + uint16 Step; + uint16 Idx; + uint16 AdditionItemID; + int32 RemainGold; + int32 RemainSilver; + int32 RemainBronze; } __attribute__((packed)); struct packet_roulette_itemrecv_req { - short PacketType; - unsigned char Condition; + int16 PacketType; + uint8 Condition; } __attribute__((packed)); struct packet_roulette_itemrecv_ack { - short PacketType; - unsigned char Result; - unsigned short AdditionItemID; + int16 PacketType; + uint8 Result; + uint16 AdditionItemID; } __attribute__((packed)); struct packet_itemlist_normal { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; struct NORMALITEM_INFO list[MAX_ITEMLIST]; } __attribute__((packed)); struct packet_itemlist_equip { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; struct EQUIPITEM_INFO list[MAX_ITEMLIST]; } __attribute__((packed)); struct packet_storelist_normal { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; #if PACKETVER >= 20120925 char name[NAME_LENGTH]; #endif @@ -973,8 +973,8 @@ struct packet_storelist_normal { } __attribute__((packed)); struct packet_storelist_equip { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; #if PACKETVER >= 20120925 char name[NAME_LENGTH]; #endif @@ -982,124 +982,124 @@ struct packet_storelist_equip { } __attribute__((packed)); struct packet_equip_item { - short PacketType; - unsigned short index; + int16 PacketType; + uint16 index; #if PACKETVER >= 20120925 - unsigned int wearLocation; + uint32 wearLocation; #else - unsigned short wearLocation; + uint16 wearLocation; #endif } __attribute__((packed)); struct packet_equipitem_ack { - short PacketType; - unsigned short index; + int16 PacketType; + uint16 index; #if PACKETVER >= 20120925 - unsigned int wearLocation; + uint32 wearLocation; #else - unsigned short wearLocation; + uint16 wearLocation; #endif #if PACKETVER >= 20100629 - unsigned short wItemSpriteNumber; + uint16 wItemSpriteNumber; #endif - unsigned char result; + uint8 result; } __attribute__((packed)); struct packet_unequipitem_ack { - short PacketType; - unsigned short index; + int16 PacketType; + uint16 index; #if PACKETVER >= 20120925 - unsigned int wearLocation; + uint32 wearLocation; #else - unsigned short wearLocation; + uint16 wearLocation; #endif - unsigned char result; + uint8 result; } __attribute__((packed)); struct packet_viewequip_ack { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; char characterName[NAME_LENGTH]; - short job; - short head; - short accessory; - short accessory2; - short accessory3; + int16 job; + int16 head; + int16 accessory; + int16 accessory2; + int16 accessory3; #if PACKETVER >= 20101124 - short robe; + int16 robe; #endif - short headpalette; - short bodypalette; - unsigned char sex; + int16 headpalette; + int16 bodypalette; + uint8 sex; struct EQUIPITEM_INFO list[MAX_INVENTORY]; } __attribute__((packed)); struct packet_notify_bounditem { - short PacketType; - unsigned short index; + int16 PacketType; + uint16 index; } __attribute__((packed)); struct packet_skill_entry { - short PacketType; + int16 PacketType; #if PACKETVER >= 20110718 - short PacketLength; + int16 PacketLength; #endif - unsigned int AID; - unsigned int creatorAID; - short xPos; - short yPos; + uint32 AID; + uint32 creatorAID; + int16 xPos; + int16 yPos; #if PACKETVER >= 20121212 - int job; + int32 job; #else - unsigned char job; + uint8 job; #endif #if PACKETVER >= 20110718 - char RadiusRange; + int8 RadiusRange; #endif - unsigned char isVisible; + uint8 isVisible; #if PACKETVER >= 20130731 - unsigned char level; + uint8 level; #endif } __attribute__((packed)); struct packet_graffiti_entry { - short PacketType; - unsigned int AID; - unsigned int creatorAID; - short xPos; - short yPos; - unsigned char job; - unsigned char isVisible; - unsigned char isContens; + int16 PacketType; + uint32 AID; + uint32 creatorAID; + int16 xPos; + int16 yPos; + uint8 job; + uint8 isVisible; + uint8 isContens; char msg[80]; } __attribute__((packed)); struct packet_damage { - short PacketType; - unsigned int GID; - unsigned int targetGID; - unsigned int startTime; - int attackMT; - int attackedMT; + int16 PacketType; + uint32 GID; + uint32 targetGID; + uint32 startTime; + int32 attackMT; + int32 attackedMT; #if PACKETVER < 20071113 - short damage; + int16 damage; #else - int damage; + int32 damage; #endif #if PACKETVER >= 20131223 - unsigned char is_sp_damaged; + uint8 is_sp_damaged; #endif - short count; - unsigned char action; + int16 count; + uint8 action; #if PACKETVER < 20071113 - short leftDamage; + int16 leftDamage; #else - int leftDamage; + int32 leftDamage; #endif } __attribute__((packed)); struct packet_gm_monster_item { - short PacketType; + int16 PacketType; #if PACKETVER >= 20131218 char str[100]; #else @@ -1108,35 +1108,35 @@ struct packet_gm_monster_item { } __attribute__((packed)); struct packet_npc_market_purchase { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; struct { - unsigned short ITID; - int qty; + uint16 ITID; + int32 qty; } list[]; // Note: We assume this should be <= MAX_INVENTORY (since you can't hold more than MAX_INVENTORY items thus cant buy that many at once). } __attribute__((packed)); struct packet_npc_market_result_ack { - short PacketType; - short PacketLength; - unsigned char result; + int16 PacketType; + int16 PacketLength; + uint8 result; struct { - unsigned short ITID; - unsigned short qty; - unsigned int price; + uint16 ITID; + uint16 qty; + uint32 price; } list[MAX_INVENTORY];/* assuming MAX_INVENTORY is max since you can't hold more than MAX_INVENTORY items thus cant buy that many at once. */ } __attribute__((packed)); struct packet_npc_market_open { - short PacketType; - short PacketLength; + int16 PacketType; + int16 PacketLength; /* inner struct figured by Ind after some annoying hour of debugging (data Thanks to Yommy) */ struct { - unsigned short nameid; - unsigned char type; - unsigned int price; - unsigned int qty; - unsigned short view; + uint16 nameid; + uint8 type; + uint32 price; + uint32 qty; + uint16 view; // It seems that the client doesn't have any hard-coded limit for this list // it's possible to send up to 1890 items without dropping a packet that's // too large [Panikon] @@ -1144,30 +1144,30 @@ struct packet_npc_market_open { } __attribute__((packed)); struct packet_wis_end { - short PacketType; - char result; + int16 PacketType; + int8 result; #if PACKETVER >= 20131223 - unsigned int unknown;/* maybe AID, not sure what for (works sending as 0) */ + uint32 unknown;/* maybe AID, not sure what for (works sending as 0) */ #endif } __attribute__((packed)); struct packet_party_leader_changed { - short PacketType; - unsigned int prev_leader_aid; - unsigned int new_leader_aid; + int16 PacketType; + uint32 prev_leader_aid; + uint32 new_leader_aid; } __attribute__((packed)); struct packet_hotkey { #ifdef HOTKEY_SAVING - short PacketType; + int16 PacketType; #if PACKETVER >= 20141022 - char Rotate; + int8 Rotate; #endif struct { - char isSkill; // 0: Item, 1:Skill - unsigned int ID; // Item/Skill ID - short count; // Item Quantity/Skill Level + int8 isSkill; // 0: Item, 1:Skill + uint32 ID; // Item/Skill ID + int16 count; // Item Quantity/Skill Level } hotkey[MAX_HOTKEYS]; #else // not HOTKEY_SAVING UNAVAILABLE_STRUCT; @@ -1215,6 +1215,19 @@ struct packet_quest_list_header { //struct packet_quest_list_info list[]; // Variable-length } __attribute__((packed)); +struct packet_chat_message { + uint16 packet_id; + int16 packet_len; + char message[]; +} __attribute__((packed)); + +struct packet_whisper_message { + uint16 packet_id; + int16 packet_len; + char name[NAME_LENGTH]; + char message[]; +} __attribute__((packed)); + #if !defined(sun) && (!defined(__NETBSD__) || __NetBSD_Version__ >= 600000000) // NetBSD 5 and Solaris don't like pragma pack but accept the packed attribute #pragma pack(pop) #endif // not NetBSD < 6 / Solaris diff --git a/src/map/party.c b/src/map/party.c index 551c4d56f..d0d466083 100644 --- a/src/map/party.c +++ b/src/map/party.c @@ -58,6 +58,9 @@ struct party_interface *party; * Used when creating/adding people to a party. [Skotlex] *------------------------------------------*/ void party_fill_member(struct party_member* member, struct map_session_data* sd, unsigned int leader) { + nullpo_retv(member); + nullpo_retv(sd); + member->account_id = sd->status.account_id; member->char_id = sd->status.char_id; safestrncpy(member->name, sd->status.name, NAME_LENGTH); @@ -162,6 +165,9 @@ int party_create(struct map_session_data *sd, const char *name,int item,int item struct party_member leader; char tname[NAME_LENGTH]; + nullpo_retr(0, sd); + nullpo_retr(0, name); + safestrncpy(tname, name, NAME_LENGTH); trim(tname); @@ -228,6 +234,7 @@ int party_recv_noinfo(int party_id, int char_id) { void party_check_state(struct party_data *p) { int i; + nullpo_retv(p); memset(&p->state, 0, sizeof(p->state)); for (i = 0; i < MAX_PARTY; i ++) { if (!p->party.member[i].online) continue; //Those not online shouldn't apart to skill usage and all that. @@ -407,6 +414,8 @@ void party_reply_invite(struct map_session_data *sd,int party_id,int flag) { struct map_session_data* tsd; struct party_member member; + nullpo_retv(sd); + if( sd->party_invite != party_id ) {// forged sd->party_invite = 0; @@ -436,8 +445,11 @@ void party_reply_invite(struct map_session_data *sd,int party_id,int flag) { //- Player must be authed/active and belong to a party before calling this method void party_member_joined(struct map_session_data *sd) { - struct party_data* p = party->search(sd->status.party_id); + struct party_data* p; int i; + + nullpo_retv(sd); + p = party->search(sd->status.party_id); if (!p) { party->request_info(sd->status.party_id, sd->status.char_id); return; @@ -536,6 +548,7 @@ int party_removemember(struct map_session_data* sd, int account_id, const char * if( !p->party.member[i].leader ) return 0; // only party leader may remove members + nullpo_retr(0, name); ARR_FIND( 0, MAX_PARTY, i, p->party.member[i].account_id == account_id && strncmp(p->party.member[i].name,name,NAME_LENGTH) == 0 ); if( i == MAX_PARTY ) return 0; // no such char in party @@ -550,6 +563,7 @@ int party_leave(struct map_session_data *sd) struct party_data *p; int i; + nullpo_ret(sd); p = party->search(sd->status.party_id); if( p == NULL ) return 0; @@ -743,6 +757,8 @@ void party_send_movemap(struct map_session_data *sd) { struct party_data *p; + nullpo_retv(sd); + if( sd->status.party_id==0 ) return; @@ -782,6 +798,8 @@ int party_send_logout(struct map_session_data *sd) struct party_data *p; int i; + nullpo_ret(sd); + if(!sd->status.party_id) return 0; @@ -798,12 +816,19 @@ int party_send_logout(struct map_session_data *sd) return 1; } -int party_send_message(struct map_session_data *sd,const char *mes,int len) +int party_send_message(struct map_session_data *sd, const char *mes) { - if(sd->status.party_id==0) + int len; + + nullpo_ret(sd); + nullpo_ret(mes); + + len = (int)strlen(mes); + + if (sd->status.party_id == 0) return 0; - intif->party_message(sd->status.party_id,sd->status.account_id,mes,len); - party->recv_message(sd->status.party_id,sd->status.account_id,mes,len); + intif->party_message(sd->status.party_id, sd->status.account_id, mes, len); + party->recv_message(sd->status.party_id, sd->status.account_id, mes, len); // Chat logging type 'P' / Party Chat logs->chat(LOG_CHAT_PARTY, sd->status.party_id, sd->status.char_id, sd->status.account_id, mapindex_id2name(sd->mapindex), sd->bl.x, sd->bl.y, NULL, mes); @@ -843,6 +868,8 @@ int party_skill_check(struct map_session_data *sd, int party_id, uint16 skill_id return 0; //Unknown case? } + nullpo_ret(sd); + for(i=0;i<MAX_PARTY;i++){ if ((p_sd = p->data[i].sd) == NULL) continue; @@ -930,11 +957,9 @@ int party_exp_share(struct party_data* p, struct block_list* src, unsigned int b { struct map_session_data* sd[MAX_PARTY]; unsigned int i, c; -#ifdef RENEWAL_EXP - unsigned int job_exp_bonus, base_exp_bonus; -#endif nullpo_ret(p); + nullpo_ret(src); // count the number of players eligible for exp sharing for (i = c = 0; i < MAX_PARTY; i++) { @@ -959,21 +984,7 @@ int party_exp_share(struct party_data* p, struct block_list* src, unsigned int b zeny = (unsigned int) cap_value(zeny * bonus/100, INT_MIN, INT_MAX); } -#ifdef RENEWAL_EXP - base_exp_bonus = base_exp; - job_exp_bonus = job_exp; -#endif - for (i = 0; i < c; i++) { -#ifdef RENEWAL_EXP - struct mob_data *md = BL_CAST(BL_MOB, src); - if (md != NULL && md->db->mexp == 0) { - int rate = pc->level_penalty_mod(md->level - (sd[i])->status.base_level, md->status.race, md->status.mode, 1); - - base_exp = (unsigned int)cap_value(base_exp_bonus * rate / 100, 1, UINT_MAX); - job_exp = (unsigned int)cap_value(job_exp_bonus * rate / 100, 1, UINT_MAX); - } -#endif pc->gainexp(sd[i], src, base_exp, job_exp, false); if (zeny) // zeny from mobs [Valaris] @@ -987,8 +998,12 @@ int party_share_loot(struct party_data* p, struct map_session_data* sd, struct i { struct map_session_data *target = NULL; int i; + + nullpo_ret(item_data); + if (p && p->party.item&2 && (first_charid || !(battle_config.party_share_type&1))) { + nullpo_ret(sd); //item distribution to party members. if (battle_config.party_share_type&2) { //Round Robin @@ -1050,6 +1065,7 @@ int party_share_loot(struct party_data* p, struct map_session_data* sd, struct i int party_send_dot_remove(struct map_session_data *sd) { + nullpo_ret(sd); if (sd->status.party_id) clif->party_xy_remove(sd); return 0; @@ -1065,6 +1081,7 @@ int party_sub_count(struct block_list *bl, va_list ap) nullpo_ret(bl); Assert_ret(bl->type == BL_PC); sd = BL_UCCAST(BL_PC, bl); + nullpo_ret(sd); if (sd->state.autotrade) return 0; @@ -1177,6 +1194,9 @@ void party_recruit_register(struct map_session_data *sd, short level, const char #ifdef PARTY_RECRUIT struct party_booking_ad_info *pb_ad; + nullpo_retv(sd); + nullpo_retv(notice); + pb_ad = (struct party_booking_ad_info*)idb_get(party->booking_db, sd->status.char_id); if( pb_ad == NULL ) @@ -1207,6 +1227,9 @@ void party_booking_register(struct map_session_data *sd, short level, short mapi struct party_booking_ad_info *pb_ad; int i; + nullpo_retv(sd); + nullpo_retv(job); + pb_ad = (struct party_booking_ad_info*)idb_get(party->booking_db, sd->status.char_id); if( pb_ad == NULL ) { @@ -1240,6 +1263,7 @@ void party_recruit_update(struct map_session_data *sd, const char *notice) { #ifdef PARTY_RECRUIT struct party_booking_ad_info *pb_ad; + nullpo_retv(sd); pb_ad = (struct party_booking_ad_info*)idb_get(party->booking_db, sd->status.char_id); if( pb_ad == NULL ) @@ -1261,6 +1285,9 @@ void party_booking_update(struct map_session_data *sd, short* job) { int i; struct party_booking_ad_info *pb_ad; + nullpo_retv(sd); + nullpo_retv(job); + pb_ad = (struct party_booking_ad_info*)idb_get(party->booking_db, sd->status.char_id); if( pb_ad == NULL ) @@ -1287,6 +1314,7 @@ void party_recruit_search(struct map_session_data *sd, short level, short mapid, bool more_result = false; struct DBIterator *iter = db_iterator(party->booking_db); + nullpo_retv(sd); memset(result_list, 0, sizeof(result_list)); for( pb_ad = dbi_first(iter); dbi_exists(iter); pb_ad = dbi_next(iter) ) @@ -1318,6 +1346,8 @@ void party_booking_search(struct map_session_data *sd, short level, short mapid, bool more_result = false; struct DBIterator *iter = db_iterator(party->booking_db); + nullpo_retv(sd); + memset(result_list, 0, sizeof(result_list)); for( pb_ad = dbi_first(iter); dbi_exists(iter); pb_ad = dbi_next(iter) ) { @@ -1353,6 +1383,8 @@ bool party_booking_delete(struct map_session_data *sd) { struct party_booking_ad_info* pb_ad; + nullpo_retr(false, sd); + if((pb_ad = (struct party_booking_ad_info*)idb_get(party->booking_db, sd->status.char_id))!=NULL) { #ifdef PARTY_RECRUIT diff --git a/src/map/party.h b/src/map/party.h index 253f074bb..05037eb04 100644 --- a/src/map/party.h +++ b/src/map/party.h @@ -117,7 +117,7 @@ struct party_interface { void (*send_movemap) (struct map_session_data *sd); void (*send_levelup) (struct map_session_data *sd); int (*send_logout) (struct map_session_data *sd); - int (*send_message) (struct map_session_data *sd,const char *mes,int len); + int (*send_message) (struct map_session_data *sd, const char *mes); int (*recv_message) (int party_id,int account_id,const char *mes,int len); int (*skill_check) (struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv); int (*send_xy_clear) (struct party_data *p); diff --git a/src/map/path.c b/src/map/path.c index 543497c33..f5e08d4df 100644 --- a/src/map/path.c +++ b/src/map/path.c @@ -89,6 +89,7 @@ int path_blownpos(struct block_list *bl, int16 m,int16 x0,int16 y0,int16 dx,int1 { struct map_data *md; + Assert_retr(-1, m >= 0 && m < map->count); if( !map->list[m].cell ) return -1; md = &map->list[m]; @@ -126,6 +127,8 @@ bool path_search_long(struct shootpath_data *spd,struct block_list *bl,int16 m,i struct map_data *md; struct shootpath_data s_spd; + Assert_retr(false, m >= 0 && m < map->count); + if( spd == NULL ) spd = &s_spd; // use dummy output variable @@ -254,10 +257,12 @@ static int add_path(struct node_heap *heap, struct path_node *tp, int16 x, int16 *------------------------------------------*/ bool path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell) { - register int i, j, x, y, dx, dy; + register int i, x, y, dx, dy; struct map_data *md; struct walkpath_data s_wpd; + Assert_retr(false, m >= 0 && m < map->count); + if (wpd == NULL) wpd = &s_wpd; // use dummy output variable @@ -315,8 +320,7 @@ bool path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, int1 } return false; // easy path unsuccessful - } - else { // !(flag&1) + } else { // !(flag&1) // A* (A-star) pathfinding // We always use A* for finding walkpaths because it is what game client uses. // Easy pathfinding cuts corners of non-walkable cells, but client always walks around it. @@ -331,6 +335,7 @@ bool path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, int1 int xs = md->xs - 1; int ys = md->ys - 1; int len = 0; + int j; memset(tp, 0, sizeof(tp)); // Start node @@ -407,7 +412,7 @@ bool path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, int1 } for (it = current; it->parent != NULL; it = it->parent, len++); - if (len > sizeof(wpd->path)) { + if (len > (int)sizeof(wpd->path)) { return false; } diff --git a/src/map/pc.c b/src/map/pc.c index 57b2fe19a..2206dbb80 100644 --- a/src/map/pc.c +++ b/src/map/pc.c @@ -81,8 +81,10 @@ struct pc_interface *pc; //Note that it does not do a validity check for speed purposes, where parsing //player input make sure to use a pc->db_checkid first! int pc_class2idx(int class_) { - if (class_ >= JOB_NOVICE_HIGH) - return class_- JOB_NOVICE_HIGH+JOB_MAX_BASIC; + if (class_ >= JOB_NOVICE_HIGH) { + class_ += - JOB_NOVICE_HIGH + JOB_MAX_BASIC; + } + Assert_ret(class_ >= 0 && class_ < CLASS_COUNT); return class_; } @@ -109,6 +111,7 @@ struct map_session_data* pc_get_dummy_sd(void) int pc_set_group(struct map_session_data *sd, int group_id) { GroupSettings *group = pcg->id2group(group_id); + nullpo_retr(1, sd); if (group == NULL) return 1; sd->group_id = group_id; @@ -121,6 +124,7 @@ int pc_set_group(struct map_session_data *sd, int group_id) */ bool pc_should_log_commands(struct map_session_data *sd) { + nullpo_retr(true, sd); return pcg->should_log_commands(sd->group); } @@ -141,7 +145,8 @@ int pc_invincible_timer(int tid, int64 tick, int id, intptr_t data) return 0; } -void pc_setinvincibletimer(struct map_session_data* sd, int val) { +void pc_setinvincibletimer(struct map_session_data* sd, int val) +{ nullpo_retv(sd); val += map->list[sd->bl.m].invincible_time_inc; @@ -466,6 +471,7 @@ int pc_inventory_rental_end(int tid, int64 tick, int id, intptr_t data) { int pc_inventory_rental_clear(struct map_session_data *sd) { + nullpo_ret(sd); if( sd->rental_timer != INVALID_TIMER ) { timer->delete(sd->rental_timer, pc->inventory_rental_end); @@ -476,7 +482,11 @@ int pc_inventory_rental_clear(struct map_session_data *sd) } /* assumes i is valid (from default areas where it is called, it is) */ void pc_rental_expire(struct map_session_data *sd, int i) { - short nameid = sd->status.inventory[i].nameid; + short nameid; + + nullpo_retv(sd); + Assert_retv(i >= 0 && i < MAX_INVENTORY); + nameid = sd->status.inventory[i].nameid; /* Soon to be dropped, we got plans to integrate it with item db */ switch( nameid ) { @@ -547,6 +557,7 @@ void pc_inventory_rentals(struct map_session_data *sd) int i, c = 0; int64 expire_tick, next_tick = INT64_MAX; + nullpo_retv(sd); for( i = 0; i < MAX_INVENTORY; i++ ) { // Check for Rentals on Inventory if( sd->status.inventory[i].nameid == 0 ) @@ -686,6 +697,7 @@ int pc_equippoint(struct map_session_data *sd,int n) int ep = 0; nullpo_ret(sd); + Assert_ret(n >= 0 && n < MAX_INVENTORY); if(!sd->inventory_data[n]) return 0; @@ -812,6 +824,7 @@ bool pc_isequipped(struct map_session_data *sd, int nameid) { int i, j; + nullpo_retr(false, sd); for (i = 0; i < EQI_MAX; i++) { int index = sd->equip_index[i]; if( index < 0 ) continue; @@ -891,6 +904,7 @@ bool pc_adoption(struct map_session_data *p1_sd, struct map_session_data *p2_sd, if( !pc->can_Adopt(p1_sd, p2_sd, b_sd) ) return false; + nullpo_retr(false, b_sd); // Preserve current job levels and progress joblevel = b_sd->status.job_level; jobexp = b_sd->status.job_exp; @@ -1039,7 +1053,10 @@ bool pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_tim { int i; int64 tick = timer->gettick(); - uint32 ip = sockt->session[sd->fd]->client_addr; + uint32 ip; + + nullpo_retr(false, sd); + ip = sockt->session[sd->fd]->client_addr; sd->login_id2 = login_id2; @@ -1269,6 +1286,7 @@ bool pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_tim *------------------------------------------*/ void pc_authfail(struct map_session_data *sd) { + nullpo_retv(sd); clif->authfail_fd(sd->fd, 0); return; } @@ -1306,6 +1324,7 @@ int pc_reg_received(struct map_session_data *sd) { int i, idx = 0; + nullpo_ret(sd); sd->vars_ok = true; sd->change_level_2nd = pc_readglobalreg(sd,script->add_str("jobchange_level")); @@ -1632,6 +1651,7 @@ void pc_check_skilltree(struct map_session_data *sd, int skill_id) if(battle_config.skillfree) return; //Function serves no purpose if this is set + nullpo_retv(sd); i = pc->calc_skilltree_normalize_job(sd); c = pc->mapid2jobid(i, sd->status.sex); if (c == -1) { //Unable to normalize job?? @@ -1697,6 +1717,7 @@ void pc_check_skilltree(struct map_session_data *sd, int skill_id) int pc_clean_skilltree(struct map_session_data *sd) { int i; + nullpo_ret(sd); for (i = 0; i < MAX_SKILL; i++){ if (sd->status.skill[i].flag == SKILL_FLAG_TEMPORARY || sd->status.skill[i].flag == SKILL_FLAG_PLAGIARIZED) { sd->status.skill[i].id = 0; @@ -1714,8 +1735,10 @@ int pc_clean_skilltree(struct map_session_data *sd) int pc_calc_skilltree_normalize_job(struct map_session_data *sd) { int skill_point, novice_skills; - int c = sd->class_; + int c; + nullpo_ret(sd); + c = sd->class_; if (!battle_config.skillup_limit || pc_has_permission(sd, PC_PERM_ALL_SKILL)) return c; @@ -1822,6 +1845,7 @@ int pc_updateweightstatus(struct map_session_data *sd) } int pc_disguise(struct map_session_data *sd, int class_) { + nullpo_ret(sd); if (class_ == -1 && sd->disguise == -1) return 0; if (class_ >= 0 && sd->disguise == class_) @@ -1864,8 +1888,8 @@ int pc_disguise(struct map_session_data *sd, int class_) { clif->cartlist(sd); clif->updatestatus(sd,SP_CARTINFO); } - if (sd->chatID) { - struct chat_data *cd = map->id2cd(sd->chatID); + if (sd->chat_id != 0) { + struct chat_data *cd = map->id2cd(sd->chat_id); if (cd != NULL) clif->dispchat(cd,0); @@ -1881,6 +1905,8 @@ int pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv, s if( !rate ) return 0; + nullpo_ret(spell); + Assert_ret(max <= 15); // autospell array size for( i = 0; i < max && spell[i].id; i++ ) { if( (spell[i].card_id == card_id || spell[i].rate < 0 || rate < 0) && spell[i].id == id && spell[i].lv == lv ) @@ -1917,6 +1943,8 @@ int pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_ski if( !rate ) return 0; + nullpo_ret(spell); + Assert_ret(max <= 15); // autospell array size for( i = 0; i < max && spell[i].id; i++ ) { ; // each autospell works independently @@ -1952,6 +1980,8 @@ int pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_ski int pc_bonus_addeff(struct s_addeffect* effect, int max, enum sc_type id, int16 rate, int16 arrow_rate, uint8 flag, uint16 duration) { int i; + + nullpo_ret(effect); if (!(flag&(ATF_SHORT|ATF_LONG))) flag|=ATF_SHORT|ATF_LONG; //Default range: both if (!(flag&(ATF_TARGET|ATF_SELF))) @@ -1981,6 +2011,8 @@ int pc_bonus_addeff(struct s_addeffect* effect, int max, enum sc_type id, int16 int pc_bonus_addeff_onskill(struct s_addeffectonskill* effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target) { int i; + + nullpo_ret(effect); for( i = 0; i < max && effect[i].skill; i++ ) { if( effect[i].id == id && effect[i].skill == skill_id && effect[i].target == target ) { effect[i].rate += rate; @@ -2001,6 +2033,7 @@ int pc_bonus_addeff_onskill(struct s_addeffectonskill* effect, int max, enum sc_ int pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, short group, int race_mask, int rate) { int i; + nullpo_ret(drop); //Apply config rate adjustment settings. if (rate >= 0) { //Absolute drop. if (battle_config.item_rate_adddrop != 100) @@ -2048,6 +2081,8 @@ int pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, short int pc_addautobonus(struct s_autobonus *bonus,char max,const char *bonus_script,short rate,unsigned int dur,short flag,const char *other_script,unsigned short pos,bool onskill) { int i; + nullpo_ret(bonus); + nullpo_ret(bonus_script); ARR_FIND(0, max, i, bonus[i].rate == 0); if( i == max ) { @@ -2084,6 +2119,7 @@ int pc_delautobonus(struct map_session_data* sd, struct s_autobonus *autobonus,c { int i; nullpo_ret(sd); + nullpo_ret(autobonus); for( i = 0; i < max; i++ ) { @@ -2155,6 +2191,7 @@ int pc_bonus_addele(struct map_session_data* sd, unsigned char ele, short rate, int i; struct weapon_data* wd; + nullpo_ret(sd); wd = (sd->state.lr_flag ? &sd->left_weapon : &sd->right_weapon); ARR_FIND(0, MAX_PC_BONUS, i, wd->addele2[i].rate == 0); @@ -2188,6 +2225,7 @@ int pc_bonus_subele(struct map_session_data* sd, unsigned char ele, short rate, { int i; + nullpo_ret(sd); ARR_FIND(0, MAX_PC_BONUS, i, sd->subele2[i].rate == 0); if (i == MAX_PC_BONUS) @@ -4093,7 +4131,7 @@ bool pc_can_insert_card_into(struct map_session_data* sd, int idx_card, int idx_ ARR_FIND( 0, sd->inventory_data[idx_equip]->slot, i, sd->status.inventory[idx_equip].card[i] == 0); if (i == sd->inventory_data[idx_equip]->slot) return false; // no free slots - return true; + return true; } /** @@ -4113,7 +4151,7 @@ bool pc_can_insert_card(struct map_session_data* sd, int idx_card) return false; // target card missing if (sd->inventory_data[idx_card]->type != IT_CARD) return false; // must be a card - return true; + return true; } /*========================================== @@ -4276,7 +4314,7 @@ int pc_payzeny(struct map_session_data *sd,int zeny, enum e_log_pick_type type, if( zeny > 0 && sd->state.showzeny ) { char output[255]; sprintf(output, "Removed %dz.", zeny); - clif_disp_onlyself(sd,output,strlen(output)); + clif_disp_onlyself(sd, output); } return 0; @@ -4318,7 +4356,7 @@ int pc_paycash(struct map_session_data *sd, int price, int points) { char output[128]; sprintf(output, msg_sd(sd,504), points, cash, sd->kafraPoints, sd->cashPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); } return cash+points; } @@ -4343,7 +4381,7 @@ int pc_getcash(struct map_session_data *sd, int cash, int points) if( battle_config.cashshop_show_points ) { sprintf(output, msg_sd(sd,505), cash, sd->cashPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); } return cash; } @@ -4366,7 +4404,7 @@ int pc_getcash(struct map_session_data *sd, int cash, int points) if( battle_config.cashshop_show_points ) { sprintf(output, msg_sd(sd,506), points, sd->kafraPoints); - clif_disp_onlyself(sd, output, strlen(output)); + clif_disp_onlyself(sd, output); } return points; } @@ -4404,7 +4442,7 @@ int pc_getzeny(struct map_session_data *sd,int zeny, enum e_log_pick_type type, if( zeny > 0 && sd->state.showzeny ) { char output[255]; sprintf(output, "Gained %dz.", zeny); - clif_disp_onlyself(sd,output,strlen(output)); + clif_disp_onlyself(sd, output); } return 0; @@ -4563,6 +4601,7 @@ int pc_additem(struct map_session_data *sd,struct item *item_data,int amount,e_l int pc_delitem(struct map_session_data *sd,int n,int amount,int type, short reason, e_log_pick_type log_type) { nullpo_retr(1, sd); + Assert_retr(1, n >= 0 && n < MAX_INVENTORY); if(sd->status.inventory[n].nameid==0 || amount <= 0 || sd->status.inventory[n].amount<amount || sd->inventory_data[n] == NULL) return 1; @@ -4706,6 +4745,7 @@ int pc_isUseitem(struct map_session_data *sd,int n) int nameid; nullpo_ret(sd); + Assert_ret(n >= 0 && n < MAX_INVENTORY); item = sd->inventory_data[n]; nameid = sd->status.inventory[n].nameid; @@ -4892,6 +4932,7 @@ int pc_useitem(struct map_session_data *sd,int n) { bool removeItem = false; nullpo_ret(sd); + Assert_ret(n >= 0 && n < MAX_INVENTORY); if( sd->npc_id || sd->state.workinprogress&1 ){ /* TODO: add to clif->messages enum */ @@ -5112,6 +5153,7 @@ int pc_cart_additem(struct map_session_data *sd,struct item *item_data,int amoun int pc_cart_delitem(struct map_session_data *sd,int n,int amount,int type,e_log_pick_type log_type) { struct item_data * data; nullpo_retr(1, sd); + Assert_retr(1, n >= 0 && n < MAX_INVENTORY); if( sd->status.cart[n].nameid == 0 || sd->status.cart[n].amount < amount || !(data = itemdb->exists(sd->status.cart[n].nameid)) ) return 1; @@ -5170,6 +5212,7 @@ int pc_cartitem_amount(struct map_session_data* sd, int idx, int amount) struct item* item_data; nullpo_retr(-1, sd); + Assert_retr(-1, idx >= 0 && idx < MAX_CART); item_data = &sd->status.cart[idx]; if( item_data->nameid == 0 || item_data->amount == 0 ) @@ -5204,9 +5247,12 @@ int pc_getitemfromcart(struct map_session_data *sd,int idx,int amount) return flag; } -void pc_bound_clear(struct map_session_data *sd, enum e_item_bound_type type) { + +void pc_bound_clear(struct map_session_data *sd, enum e_item_bound_type type) +{ int i; + nullpo_retv(sd); switch( type ) { /* both restricted to inventory */ case IBT_PARTY: @@ -5341,7 +5387,7 @@ int pc_steal_item(struct map_session_data *sd,struct block_list *bl, uint16 skil char message[128]; sprintf (message, msg_txt(542), sd->status.name, md->db->jname, data->jname, (float)md->db->dropitem[i].p / 100); //MSG: "'%s' stole %s's %s (chance: %0.02f%%)" - intif->broadcast(message, strlen(message)+1, BC_DEFAULT); + intif->broadcast(message, (int)strlen(message)+1, BC_DEFAULT); } return 1; } @@ -6440,6 +6486,7 @@ int pc_check_job_name(const char *name) { { "Rebellion", JOB_REBELLION }, }; + nullpo_retr(-1, name); len = ARRAYLENGTH(names); ARR_FIND(0, len, i, strcmpi(names[i].name, name) == 0); @@ -6506,6 +6553,7 @@ int pc_stop_following (struct map_session_data *sd) int pc_follow(struct map_session_data *sd,int target_id) { struct block_list *bl = map->id2bl(target_id); + nullpo_retr(1, sd); if (bl == NULL /*|| bl->type != BL_PC*/) return 1; if (sd->followtimer != INVALID_TIMER) @@ -6520,6 +6568,7 @@ int pc_follow(struct map_session_data *sd,int target_id) { int pc_checkbaselevelup(struct map_session_data *sd) { unsigned int next = pc->nextbaseexp(sd); + nullpo_ret(sd); if (!next || sd->status.base_exp < next) return 0; @@ -6569,6 +6618,7 @@ int pc_checkbaselevelup(struct map_session_data *sd) { void pc_baselevelchanged(struct map_session_data *sd) { int i; + nullpo_retv(sd); for( i = 0; i < EQI_MAX; i++ ) { if( sd->equip_index[i] >= 0 ) { if( sd->inventory_data[ sd->equip_index[i] ]->elvmax && sd->status.base_level > (unsigned int)sd->inventory_data[ sd->equip_index[i] ]->elvmax ) @@ -6613,34 +6663,72 @@ int pc_checkjoblevelup(struct map_session_data *sd) * Alters EXP based on self bonuses that do not get shared with the party **/ void pc_calcexp(struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src) { - int bonus = 0; - struct status_data *st = status->get_status_data(src); + int buff_ratio = 0, buff_job_ratio = 0, race_ratio = 0, pk_ratio = 0; + int64 jexp, bexp; - if (sd->expaddrace[st->race]) - bonus += sd->expaddrace[st->race]; - bonus += sd->expaddrace[(st->mode&MD_BOSS) ? RC_BOSS : RC_NONBOSS]; + nullpo_retv(sd); + nullpo_retv(base_exp); + nullpo_retv(job_exp); - if (battle_config.pk_mode - && (int)(status->get_lv(src) - sd->status.base_level) >= 20) - bonus += 15; // pk_mode additional exp if monster >20 levels [Valaris] + jexp = *job_exp; + bexp = *base_exp; - if (sd->sc.data[SC_CASH_PLUSEXP]) - bonus += sd->sc.data[SC_CASH_PLUSEXP]->val1; - if (sd->sc.data[SC_OVERLAPEXPUP]) - bonus += sd->sc.data[SC_OVERLAPEXPUP]->val1; + if (src != NULL) { + const struct status_data *st = status->get_status_data(src); + +#ifdef RENEWAL_EXP //should happen first before we caluclate any modifiers + if (src->type == BL_MOB) { + const struct mob_data *md = BL_UCAST(BL_MOB, src); + int re_mod; + re_mod = pc->level_penalty_mod(md->level - sd->status.base_level, md->status.race, md->status.mode, 1); + jexp = apply_percentrate64(jexp, re_mod, 100); + bexp = apply_percentrate64(bexp, re_mod, 100); + } +#endif + + //Race modifier + if (sd->expaddrace[st->race]) + race_ratio += sd->expaddrace[st->race]; + race_ratio += sd->expaddrace[(st->mode&MD_BOSS) ? RC_BOSS : RC_NONBOSS]; + } - *base_exp = (unsigned int) cap_value(*base_exp + apply_percentrate64(*base_exp, bonus, 100), 1, UINT_MAX); + //PK modifier + /* this doesn't exist in Aegis, instead there's a CrazyKiller check which double all EXP from this point */ + if (battle_config.pk_mode && (int)(status->get_lv(src) - sd->status.base_level) >= 20) + pk_ratio += 15; // pk_mode additional exp if monster >20 levels [Valaris] + + + //Buffs modifier + if (sd->sc.data[SC_CASH_PLUSEXP]) { + buff_job_ratio += sd->sc.data[SC_CASH_PLUSEXP]->val1; + buff_ratio += sd->sc.data[SC_CASH_PLUSEXP]->val1; + } + if (sd->sc.data[SC_OVERLAPEXPUP]) { + buff_job_ratio += sd->sc.data[SC_OVERLAPEXPUP]->val1; + buff_ratio += sd->sc.data[SC_OVERLAPEXPUP]->val1; + } if (sd->sc.data[SC_CASH_PLUSONLYJOBEXP]) - bonus += sd->sc.data[SC_CASH_PLUSONLYJOBEXP]->val1; + buff_job_ratio += sd->sc.data[SC_CASH_PLUSONLYJOBEXP]->val1; - *job_exp = (unsigned int) cap_value(*job_exp + apply_percentrate64(*job_exp, bonus, 100), 1, UINT_MAX); + //Applying Race and PK modifier First then Premium (Perment modifier) and finally buff modifier + jexp += apply_percentrate64(jexp, race_ratio, 100); + jexp += apply_percentrate64(jexp, pk_ratio, 100); + + bexp += apply_percentrate64(bexp, race_ratio, 100); + bexp += apply_percentrate64(bexp, pk_ratio, 100); - if (sd->status.mod_exp != 100) { - *base_exp = (unsigned int) cap_value(apply_percentrate64(*base_exp, sd->status.mod_exp, 100), 1, UINT_MAX); - *job_exp = (unsigned int) cap_value(apply_percentrate64(*job_exp, sd->status.mod_exp, 100), 1, UINT_MAX); + if (sd->status.mod_exp != 100) { + jexp = apply_percentrate64(jexp, sd->status.mod_exp, 100); + bexp = apply_percentrate64(bexp, sd->status.mod_exp, 100); } + + bexp += apply_percentrate64(bexp, buff_ratio, 100); + jexp += apply_percentrate64(jexp, buff_ratio + buff_job_ratio, 100); + + *job_exp = (unsigned int)cap_value(jexp, 1, UINT_MAX); + *base_exp = (unsigned int)cap_value(bexp, 1, UINT_MAX); } /** @@ -6654,24 +6742,25 @@ bool pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned in unsigned int nextb=0, nextj=0; nullpo_ret(sd); - if(sd->bl.prev == NULL || pc_isdead(sd)) + if (sd->bl.prev == NULL || pc_isdead(sd)) return false; - if(!battle_config.pvp_exp && map->list[sd->bl.m].flag.pvp) // [MouseJstr] + if (!battle_config.pvp_exp && map->list[sd->bl.m].flag.pvp) // [MouseJstr] return false; // no exp on pvp maps - if( pc_has_permission(sd,PC_PERM_DISABLE_EXP) ) + if (pc_has_permission(sd,PC_PERM_DISABLE_EXP)) return false; - if(sd->status.guild_id>0) - base_exp-=guild->payexp(sd,base_exp); + if (src) + pc->calcexp(sd, &base_exp, &job_exp, src); - if(src) pc->calcexp(sd, &base_exp, &job_exp, src); + if (sd->status.guild_id > 0) + base_exp -= guild->payexp(sd,base_exp); nextb = pc->nextbaseexp(sd); nextj = pc->nextjobexp(sd); - if(sd->state.showexp || battle_config.max_exp_gain_rate){ + if (sd->state.showexp || battle_config.max_exp_gain_rate) { if (nextb > 0) nextbp = (float) base_exp / (float) nextb; if (nextj > 0) @@ -6726,7 +6815,7 @@ bool pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned in char output[256]; sprintf(output, "Experience Gained Base:%u (%.2f%%) Job:%u (%.2f%%)",base_exp,nextbp*(float)100,job_exp,nextjp*(float)100); - clif_disp_onlyself(sd,output,strlen(output)); + clif_disp_onlyself(sd, output); } return true; @@ -7875,6 +7964,7 @@ int pc_dead(struct map_session_data *sd,struct block_list *src) { } void pc_revive(struct map_session_data *sd,unsigned int hp, unsigned int sp) { + nullpo_retv(sd); if(hp) clif->updatestatus(sd,SP_HP); if(sp) clif->updatestatus(sd,SP_SP); @@ -8210,6 +8300,7 @@ int pc_setparam(struct map_session_data *sd,int type,int val) *------------------------------------------*/ void pc_heal(struct map_session_data *sd,unsigned int hp,unsigned int sp, int type) { + nullpo_retv(sd); if (type) { if (hp) clif->heal(sd->fd,SP_HP,hp); @@ -8233,6 +8324,7 @@ int pc_itemheal(struct map_session_data *sd,int itemid, int hp,int sp) { int bonus, tmp; + nullpo_ret(sd); if(hp) { int i; bonus = 100 + (sd->battle_status.vit<<1) @@ -8803,6 +8895,7 @@ int pc_setcart(struct map_session_data *sd,int type) { **/ void pc_setfalcon(struct map_session_data *sd, bool flag) { + nullpo_retv(sd); if (flag) { if (pc->checkskill(sd,HT_FALCON) > 0) // add falcon if he have the skill pc->setoption(sd,sd->sc.option|OPTION_FALCON); @@ -8821,6 +8914,7 @@ void pc_setfalcon(struct map_session_data *sd, bool flag) **/ void pc_setridingpeco(struct map_session_data *sd, bool flag) { + nullpo_retv(sd); if (flag) { if (pc->checkskill(sd, KN_RIDING)) pc->setoption(sd, sd->sc.option|OPTION_RIDING); @@ -8839,6 +8933,7 @@ void pc_setridingpeco(struct map_session_data *sd, bool flag) **/ void pc_setmadogear(struct map_session_data *sd, bool flag) { + nullpo_retv(sd); if (flag) { if ((sd->class_&MAPID_THIRDMASK) == MAPID_MECHANIC) pc->setoption(sd, sd->sc.option|OPTION_MADOGEAR); @@ -8857,6 +8952,7 @@ void pc_setmadogear(struct map_session_data *sd, bool flag) **/ void pc_setridingdragon(struct map_session_data *sd, unsigned int type) { + nullpo_retv(sd); if (type&OPTION_DRAGON) { // Ensure only one dragon is set at a time. if (type&OPTION_DRAGON1) @@ -8889,6 +8985,7 @@ void pc_setridingdragon(struct map_session_data *sd, unsigned int type) **/ void pc_setridingwug(struct map_session_data *sd, bool flag) { + nullpo_retv(sd); if (flag) { if (pc->checkskill(sd, RA_WUGRIDER) > 0) pc->setoption(sd,sd->sc.option|OPTION_WUGRIDER); @@ -8956,6 +9053,7 @@ int pc_candrop(struct map_session_data *sd, struct item *item) * For '@type' variables (temporary numeric char reg) **/ int pc_readreg(struct map_session_data* sd, int64 reg) { + nullpo_ret(sd); return i64db_iget(sd->regs.vars, reg); } /** @@ -8964,6 +9062,7 @@ int pc_readreg(struct map_session_data* sd, int64 reg) { void pc_setreg(struct map_session_data* sd, int64 reg, int val) { unsigned int index = script_getvaridx(reg); + nullpo_retv(sd); if( val ) { i64db_iput(sd->regs.vars, reg, val); if( index ) @@ -8981,6 +9080,7 @@ void pc_setreg(struct map_session_data* sd, int64 reg, int val) { char* pc_readregstr(struct map_session_data* sd, int64 reg) { struct script_reg_str *p = NULL; + nullpo_retr(NULL, sd); p = i64db_get(sd->regs.vars, reg); return p ? p->value : NULL; @@ -8993,6 +9093,8 @@ void pc_setregstr(struct map_session_data* sd, int64 reg, const char* str) { unsigned int index = script_getvaridx(reg); struct DBData prev; + nullpo_retv(sd); + nullpo_retv(str); if( str[0] ) { p = ers_alloc(pc->str_reg_ers, struct script_reg_str); @@ -9028,6 +9130,7 @@ void pc_setregstr(struct map_session_data* sd, int64 reg, const char* str) { int pc_readregistry(struct map_session_data *sd, int64 reg) { struct script_reg_num *p = NULL; + nullpo_ret(sd); if (!sd->vars_ok) { ShowError("pc_readregistry: Trying to read reg %s before it's been loaded!\n", script->get_str(script_getvarid(reg))); //This really shouldn't happen, so it's possible the data was lost somewhere, we should request it again. @@ -9049,6 +9152,7 @@ int pc_readregistry(struct map_session_data *sd, int64 reg) { char* pc_readregistry_str(struct map_session_data *sd, int64 reg) { struct script_reg_str *p = NULL; + nullpo_retr(NULL, sd); if (!sd->vars_ok) { ShowError("pc_readregistry_str: Trying to read reg %s before it's been loaded!\n", script->get_str(script_getvarid(reg))); //This really shouldn't happen, so it's possible the data was lost somewhere, we should request it again. @@ -9072,6 +9176,7 @@ int pc_setregistry(struct map_session_data *sd, int64 reg, int val) { const char *regname = script->get_str( script_getvarid(reg) ); unsigned int index = script_getvaridx(reg); + nullpo_ret(sd); /* SAAD! those things should be stored elsewhere e.g. char ones in char table, the cash ones in account_data table! */ switch( regname[0] ) { default: //Char reg @@ -9147,6 +9252,8 @@ int pc_setregistry_str(struct map_session_data *sd, int64 reg, const char *val) const char *regname = script->get_str( script_getvarid(reg) ); unsigned int index = script_getvaridx(reg); + nullpo_ret(sd); + nullpo_ret(val); if ( !pc->reg_load && !sd->vars_ok ) { ShowError("pc_setregistry_str : refusing to set %s until vars are received.\n", regname); return 0; @@ -9224,6 +9331,7 @@ int pc_addeventtimer(struct map_session_data *sd,int tick,const char *name) { int i; nullpo_ret(sd); + nullpo_ret(name); ARR_FIND( 0, MAX_EVENTTIMER, i, sd->eventtimer[i] == INVALID_TIMER ); if( i == MAX_EVENTTIMER ) @@ -9244,6 +9352,7 @@ int pc_deleventtimer(struct map_session_data *sd,const char *name) int i; nullpo_ret(sd); + nullpo_ret(name); if (sd->eventcount <= 0) return 0; @@ -9312,6 +9421,8 @@ int pc_checkcombo(struct map_session_data *sd, struct item_data *data ) { int index, success = 0; struct pc_combos *combo; + nullpo_ret(sd); + nullpo_ret(data); for( i = 0; i < data->combos_count; i++ ) { /* ensure this isn't a duplicate combo */ @@ -9387,6 +9498,8 @@ int pc_checkcombo(struct map_session_data *sd, struct item_data *data ) { int pc_removecombo(struct map_session_data *sd, struct item_data *data ) { int i, retval = 0; + nullpo_ret(sd); + nullpo_ret(data); if( !sd->combos ) return 0;/* nothing to do here, player has no combos */ @@ -9431,6 +9544,7 @@ int pc_removecombo(struct map_session_data *sd, struct item_data *data ) { } int pc_load_combo(struct map_session_data *sd) { int i, ret = 0; + nullpo_ret(sd); for( i = 0; i < EQI_MAX; i++ ) { struct item_data *id = NULL; int idx = sd->equip_index[i]; @@ -9463,6 +9577,7 @@ int pc_load_combo(struct map_session_data *sd) { **/ void pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int n, int pos) { + nullpo_retv(sd); if ((!map_no_view(sd->bl.m,EQP_SHADOW_WEAPON) && pos & EQP_SHADOW_WEAPON) || (pos & EQP_HAND_R)) { if(id) @@ -9574,7 +9689,7 @@ int pc_equipitem(struct map_session_data *sd,int n,int req_pos) if(battle_config.battle_log) ShowInfo("equip %d(%d) %x:%x\n", sd->status.inventory[n].nameid, n, (unsigned int)(id ? id->equip : 0), (unsigned int)req_pos); - if(!pc->isequip(sd,n) || !(pos&req_pos) || sd->status.inventory[n].equip != 0 || sd->status.inventory[n].attribute==1 ) { // [Valaris] + if(!pc->isequip(sd,n) || !(pos&req_pos) || sd->status.inventory[n].equip != 0 || (sd->status.inventory[n].attribute & ATTR_BROKEN) != 0 ) { // [Valaris] // FIXME: pc->isequip: equip level failure uses 2 instead of 0 clif->equipitemack(sd,n,0,EIA_FAIL); // fail return 0; @@ -9693,6 +9808,7 @@ int pc_equipitem(struct map_session_data *sd,int n,int req_pos) **/ void pc_unequipitem_pos(struct map_session_data *sd, int n, int pos) { + nullpo_retv(sd); if (pos & EQP_HAND_R) { sd->weapontype1 = 0; sd->status.weapon = sd->weapontype2; @@ -10048,6 +10164,7 @@ int pc_calc_pvprank_sub(struct block_list *bl, va_list ap) int pc_calc_pvprank(struct map_session_data *sd) { int old; struct map_data *m; + nullpo_ret(sd); m=&map->list[sd->bl.m]; old=sd->pvp_rank; sd->pvp_rank=1; @@ -10202,6 +10319,7 @@ void pc_bleeding (struct map_session_data *sd, unsigned int diff_tick) { int hp = 0, sp = 0; + nullpo_retv(sd); if( pc_isdead(sd) ) return; @@ -10235,6 +10353,7 @@ void pc_bleeding (struct map_session_data *sd, unsigned int diff_tick) void pc_regen (struct map_session_data *sd, unsigned int diff_tick) { int hp = 0, sp = 0; + nullpo_retv(sd); if (sd->hp_regen.value) { sd->hp_regen.tick += diff_tick; while (sd->hp_regen.tick >= sd->hp_regen.rate) { @@ -10312,6 +10431,7 @@ int pc_autosave(int tid, int64 tick, int id, intptr_t data) { } int pc_daynight_timer_sub(struct map_session_data *sd,va_list ap) { + nullpo_ret(sd); if (sd->state.night != map->night_flag && map->list[sd->bl.m].flag.nightenabled) { //Night/day state does not match. clif->status_change(&sd->bl, SI_SKE, map->night_flag, 0, 0, 0, 0); //New night effect by dynamix [Skotlex] sd->state.night = map->night_flag; @@ -10335,7 +10455,7 @@ int map_day_timer(int tid, int64 tick, int id, intptr_t data) { map->night_flag = 0; // 0=day, 1=night [Yor] map->foreachpc(pc->daynight_timer_sub); safestrncpy(tmp_soutput, (data == 0) ? msg_txt(502) : msg_txt(60), sizeof(tmp_soutput)); // The day has arrived! - intif->broadcast(tmp_soutput, strlen(tmp_soutput) + 1, BC_DEFAULT); + intif->broadcast(tmp_soutput, (int)strlen(tmp_soutput) + 1, BC_DEFAULT); return 0; } @@ -10355,7 +10475,7 @@ int map_night_timer(int tid, int64 tick, int id, intptr_t data) { map->night_flag = 1; // 0=day, 1=night [Yor] map->foreachpc(pc->daynight_timer_sub); safestrncpy(tmp_soutput, (data == 0) ? msg_txt(503) : msg_txt(59), sizeof(tmp_soutput)); // The night has fallen... - intif->broadcast(tmp_soutput, strlen(tmp_soutput) + 1, BC_DEFAULT); + intif->broadcast(tmp_soutput, (int)strlen(tmp_soutput) + 1, BC_DEFAULT); return 0; } @@ -10376,6 +10496,7 @@ void pc_overheat(struct map_session_data *sd, int val) { int heat = val, skill_lv, limit[] = { 10, 20, 28, 46, 66 }; + nullpo_retv(sd); if( !pc_ismadogear(sd) || sd->sc.data[SC_OVERHEAT] ) return; // already burning @@ -10401,6 +10522,7 @@ bool pc_isautolooting(struct map_session_data *sd, int nameid) { int i = 0; + nullpo_ret(sd); if (sd->state.autoloottype && sd->state.autoloottype&(1<<itemdb_type(nameid))) return true; @@ -10589,6 +10711,7 @@ int pc_split_str(char *str,char **val,int num) { int i; + nullpo_ret(val); for (i=0; i<num && str; i++){ val[i] = str; str = strchr(str,','); @@ -10601,6 +10724,7 @@ int pc_split_str(char *str,char **val,int num) int pc_split_atoi(char* str, int* val, char sep, int max) { int i,j; + nullpo_ret(val); for (i=0; i<max; i++) { if (!str) break; val[i] = atoi(str); @@ -10618,6 +10742,7 @@ int pc_split_atoui(char* str, unsigned int* val, char sep, int max) { static int warning=0; int i,j; + nullpo_ret(val); for (i=0; i<max; i++) { double f; if (!str) break; @@ -10870,6 +10995,7 @@ bool pc_readdb_levelpenalty(char* fields[], int columns, int current) { #if defined(RENEWAL_DROP) || defined(RENEWAL_EXP) int type, race, diff; + nullpo_retr(false, fields); type = atoi(fields[0]); race = atoi(fields[1]); diff = atoi(fields[2]); @@ -11014,18 +11140,18 @@ int pc_readdb(void) { ShowError("can't read %s\n", line); return 1; } - while(fgets(line, sizeof(line), fp)) - { + while (fgets(line, sizeof(line), fp)) { char *split[10]; int lv,n; - if(line[0]=='/' && line[1]=='/') + if (line[0]=='/' && line[1]=='/') continue; - for(j=0,p=line;j<3 && p;j++){ - split[j]=p; - p=strchr(p,','); - if(p) *p++=0; + for (j = 0, p = line; j < 3 && p != NULL; j++) { + split[j] = p; + p = strchr(p,','); + if (p != NULL) + *p++ = 0; } - if( j < 2 ) + if (j < 2) continue; lv=atoi(split[0]); @@ -11037,8 +11163,8 @@ int pc_readdb(void) { if(line[0]=='/' && line[1]=='/') continue; - for ( j = ELE_NEUTRAL, p = line; j<n && j<ELE_MAX && p; j++ ) { - while(*p==32 && *p>0) + for (j = ELE_NEUTRAL, p = line; j < n && j < ELE_MAX && p != NULL; j++) { + while (*p == ' ') p++; battle->attr_fix_table[lv-1][i][j]=atoi(p); #ifndef RENEWAL @@ -11046,7 +11172,8 @@ int pc_readdb(void) { battle->attr_fix_table[lv-1][i][j] = 0; #endif p=strchr(p,','); - if(p) *p++=0; + if (p != NULL) + *p++ = 0; } i++; @@ -11112,6 +11239,7 @@ void pc_itemcd_do(struct map_session_data *sd, bool load) { int i,cursor = 0; struct item_cd* cd = NULL; + nullpo_retv(sd); if( load ) { if( !(cd = idb_get(pc->itemcd_db, sd->status.char_id)) ) { // no skill cooldown is associated with this character @@ -11143,7 +11271,10 @@ void pc_itemcd_do(struct map_session_data *sd, bool load) { } void pc_bank_deposit(struct map_session_data *sd, int money) { - unsigned int limit_check = money+sd->status.bank_vault; + unsigned int limit_check; + + nullpo_retv(sd); + limit_check = money + sd->status.bank_vault; if( money <= 0 || limit_check > MAX_BANK_ZENY ) { clif->bank_deposit(sd,BDA_OVERFLOW); @@ -11163,8 +11294,10 @@ void pc_bank_deposit(struct map_session_data *sd, int money) { } } void pc_bank_withdraw(struct map_session_data *sd, int money) { - unsigned int limit_check = money+sd->status.zeny; + unsigned int limit_check; + nullpo_retv(sd); + limit_check = money + sd->status.zeny; if (money <= 0) { clif->bank_withdraw(sd,BWA_UNKNOWN_ERROR); return; @@ -11188,6 +11321,7 @@ void pc_bank_withdraw(struct map_session_data *sd, int money) { } /* status change data arrived from char-server */ void pc_scdata_received(struct map_session_data *sd) { + nullpo_retv(sd); pc->inventory_rentals(sd); clif->show_modifiers(sd); @@ -11195,7 +11329,7 @@ void pc_scdata_received(struct map_session_data *sd) { time_t exp_time = sd->expiration_time; char tmpstr[1024]; strftime(tmpstr, sizeof(tmpstr) - 1, msg_sd(sd,501), localtime(&exp_time)); // "Your account time limit is: %d-%m-%Y %H:%M:%S." - clif->wis_message(sd->fd, map->wisp_server_name, tmpstr, strlen(tmpstr)+1); + clif->wis_message(sd->fd, map->wisp_server_name, tmpstr, (int)strlen(tmpstr)); pc->expire_check(sd); } @@ -11236,6 +11370,7 @@ int pc_global_expiration_timer(int tid, int64 tick, int id, intptr_t data) { return 0; } void pc_expire_check(struct map_session_data *sd) { + nullpo_retv(sd); /* ongoing timer */ if( sd->expiration_tid != INVALID_TIMER ) return; @@ -11293,6 +11428,7 @@ void pc_autotrade_start(struct map_session_data *sd) { int i; char *data; + nullpo_retv(sd); if (SQL_ERROR == SQL->Query(map->mysql_handle, "SELECT `itemkey`,`amount`,`price` FROM `%s` WHERE `char_id` = '%d'",map->autotrade_data_db,sd->status.char_id)) Sql_ShowDebug(map->mysql_handle); @@ -11337,6 +11473,7 @@ void pc_autotrade_start(struct map_session_data *sd) { void pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_update_action action) { int i; + nullpo_retv(sd); /* either way, this goes down */ if( action != PAUC_START ) { if (SQL_ERROR == SQL->Query(map->mysql_handle, "DELETE FROM `%s` WHERE `char_id` = '%d'",map->autotrade_data_db,sd->status.char_id)) @@ -11390,6 +11527,7 @@ void pc_autotrade_prepare(struct map_session_data *sd) { char title[MESSAGE_SIZE]; unsigned char sex; + nullpo_retv(sd); CREATE(data, struct autotrade_vending, 1); memcpy(data->vending, sd->vending, sizeof(sd->vending)); @@ -11436,6 +11574,7 @@ void pc_autotrade_populate(struct map_session_data *sd) { struct autotrade_vending *data; int i, j, k, cursor = 0; + nullpo_retv(sd); if( !(data = idb_get(pc->at_db,sd->status.char_id)) ) return; @@ -11478,6 +11617,7 @@ void pc_autotrade_populate(struct map_session_data *sd) { int pc_autotrade_final(union DBKey key, struct DBData *data, va_list ap) { struct autotrade_vending* at_v = DB->data2ptr(data); + nullpo_ret(at_v); HPM->data_store_destroy(&at_v->hdata); return 0; } @@ -11516,6 +11656,90 @@ int pc_have_magnifier(struct map_session_data *sd) return n; } +/** + * Verifies a chat message, searching for atcommands, checking if the sender + * character can chat, and updating the idle timer. + * + * @param sd The sender character. + * @param message The message text. + * @return Whether the message is a valid chat message. + */ +bool pc_process_chat_message(struct map_session_data *sd, const char *message) +{ + nullpo_retr(false, sd); + if (atcommand->exec(sd->fd, sd, message, true)) { + return false; + } + + if (!pc->can_talk(sd)) { + return false; + } + + if (battle_config.min_chat_delay != 0) { + if (DIFF_TICK(sd->cantalk_tick, timer->gettick()) > 0) { + return false; + } + sd->cantalk_tick = timer->gettick() + battle_config.min_chat_delay; + } + + pc->update_idle_time(sd, BCIDLE_CHAT); + + return true; +} + +/** + * Checks a chat message, scanning for the Super Novice prayer sequence. + * + * If a match is found, the angel is invoked or the counter is incremented as + * appropriate. + * + * @param sd The sender character. + * @param message The message text. + */ +void pc_check_supernovice_call(struct map_session_data *sd, const char *message) +{ + unsigned int next = pc->nextbaseexp(sd); + int percent = 0; + + nullpo_retv(sd); + nullpo_retv(message); + if ((sd->class_&MAPID_UPPERMASK) != MAPID_SUPER_NOVICE) + return; + if (next == 0) + next = pc->thisbaseexp(sd); + if (next == 0) + return; + + // 0%, 10%, 20%, ... + percent = (int)( ( (float)sd->status.base_exp/(float)next )*1000. ); + if ((battle_config.snovice_call_type != 0 || percent != 0) && (percent%100) == 0) { + // 10.0%, 20.0%, ..., 90.0% + switch (sd->state.snovice_call_flag) { + case 0: + if (strstr(message, msg_txt(1479))) // "Dear angel, can you hear my voice?" + sd->state.snovice_call_flag = 1; + break; + case 1: + { + char buf[256]; + snprintf(buf, 256, msg_txt(1480), sd->status.name); + if (strstr(message, buf)) // "I am %s Super Novice~" + sd->state.snovice_call_flag = 2; + } + break; + case 2: + if (strstr(message, msg_txt(1481))) // "Help me out~ Please~ T_T" + sd->state.snovice_call_flag = 3; + break; + case 3: + sc_start(NULL, &sd->bl, status->skill2sc(MO_EXPLOSIONSPIRITS), 100, 17, skill->get_time(MO_EXPLOSIONSPIRITS, 5)); //Lv17-> +50 critical (noted by Poki) [Skotlex] + clif->skill_nodamage(&sd->bl, &sd->bl, MO_EXPLOSIONSPIRITS, 5, 1); // prayer always shows successful Lv5 cast and disregards noskill restrictions + sd->state.snovice_call_flag = 0; + break; + } + } +} + void do_final_pc(void) { db_destroy(pc->itemcd_db); pc->at_db->destroy(pc->at_db,pc->autotrade_final); @@ -11871,6 +12095,9 @@ void pc_defaults(void) { pc->db_checkid = pc_db_checkid; pc->validate_levels = pc_validate_levels; + pc->check_supernovice_call = pc_check_supernovice_call; + pc->process_chat_message = pc_process_chat_message; + /** * Autotrade persistency [Ind/Hercules <3] **/ @@ -11883,6 +12110,6 @@ void pc_defaults(void) { pc->check_job_name = pc_check_job_name; pc->update_idle_time = pc_update_idle_time; - + pc->have_magnifier = pc_have_magnifier; } diff --git a/src/map/pc.h b/src/map/pc.h index b648b7113..58f7a2266 100644 --- a/src/map/pc.h +++ b/src/map/pc.h @@ -258,7 +258,7 @@ struct map_session_data { struct script_state *st; char npc_str[CHATBOX_SIZE]; // for passing npc input box text to script engine int npc_timer_id; //For player attached npc timers. [Skotlex] - unsigned int chatID; + int chat_id; int64 idletime; struct { int npc_id; @@ -610,15 +610,15 @@ END_ZEROED_BLOCK; #define pc_setsit(sd) ( (sd)->state.dead_sit = (sd)->vd.dead_sit = 2 ) #define pc_isdead(sd) ( (sd)->state.dead_sit == 1 ) #define pc_issit(sd) ( (sd)->vd.dead_sit == 2 ) -#define pc_isidle(sd) ( (sd)->chatID || (sd)->state.vending || (sd)->state.buyingstore || DIFF_TICK(sockt->last_tick, (sd)->idletime) >= battle->bc->idle_no_share ) +#define pc_isidle(sd) ( (sd)->chat_id != 0 || (sd)->state.vending || (sd)->state.buyingstore || DIFF_TICK(sockt->last_tick, (sd)->idletime) >= battle->bc->idle_no_share ) #define pc_istrading(sd) ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->state.trading ) -#define pc_cant_act(sd) ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->chatID || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend ) +#define pc_cant_act(sd) ( (sd)->npc_id || (sd)->state.vending || (sd)->state.buyingstore || (sd)->chat_id != 0 || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend ) /* equals pc_cant_act except it doesn't check for chat rooms */ #define pc_cant_act2(sd) ( (sd)->npc_id || (sd)->state.buyingstore || ((sd)->sc.opt1 && (sd)->sc.opt1 != OPT1_BURNING) || (sd)->state.trading || (sd)->state.storage_flag || (sd)->state.prevend ) #define pc_setdir(sd,b,h) ( (sd)->ud.dir = (b) ,(sd)->head_dir = (h) ) -#define pc_setchatid(sd,n) ( (sd)->chatID = n ) +#define pc_setchatid(sd,n) ( (sd)->chat_id = (n) ) #define pc_ishiding(sd) ( (sd)->sc.option&(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK) ) #define pc_iscloaking(sd) ( !((sd)->sc.option&OPTION_CHASEWALK) && ((sd)->sc.option&OPTION_CLOAK) ) #define pc_ischasewalk(sd) ( (sd)->sc.option&OPTION_CHASEWALK ) @@ -1089,8 +1089,11 @@ END_ZEROED_BLOCK; /* End */ int (*check_job_name) (const char *name); void (*update_idle_time) (struct map_session_data* sd, enum e_battle_config_idletime type); - + int (*have_magnifier) (struct map_session_data *sd); + + bool (*process_chat_message) (struct map_session_data *sd, const char *message); + void (*check_supernovice_call) (struct map_session_data *sd, const char *message); }; #ifdef HERCULES_CORE diff --git a/src/map/script.c b/src/map/script.c index 007c6e0e1..ed38ed1c5 100644 --- a/src/map/script.c +++ b/src/map/script.c @@ -83,36 +83,18 @@ struct script_interface script_s; struct script_interface *script; -static inline int GETVALUE(const unsigned char* buf, int i) { - return (int)MakeDWord(MakeWord(buf[i], buf[i+1]), MakeWord(buf[i+2], 0)); -} -static inline void SETVALUE(unsigned char* buf, int i, int n) { - buf[i] = GetByte(n, 0); - buf[i+1] = GetByte(n, 1); - buf[i+2] = GetByte(n, 2); -} - -static inline void script_string_buf_ensure(struct script_string_buf *buf, size_t ensure) { - if( buf->pos+ensure >= buf->size ) { - do { - buf->size += 512; - } while ( buf->pos+ensure >= buf->size ); - RECREATE(buf->ptr, char, buf->size); - } -} - -static inline void script_string_buf_addb(struct script_string_buf *buf,uint8 b) { - if( buf->pos+1 >= buf->size ) { - buf->size += 512; - RECREATE(buf->ptr, char, buf->size); - } - buf->ptr[buf->pos++] = b; +static inline int GETVALUE(const struct script_buf *buf, int i) +{ + Assert_ret(VECTOR_LENGTH(*buf) > i + 2); + return (int)MakeDWord(MakeWord(VECTOR_INDEX(*buf, i), VECTOR_INDEX(*buf, i+1)), + MakeWord(VECTOR_INDEX(*buf, i+2), 0)); } - -static inline void script_string_buf_destroy(struct script_string_buf *buf) { - if( buf->ptr ) - aFree(buf->ptr); - memset(buf,0,sizeof(struct script_string_buf)); +static inline void SETVALUE(struct script_buf *buf, int i, int n) +{ + Assert_retv(VECTOR_LENGTH(*buf) > i + 2); + VECTOR_INDEX(*buf, i) = GetByte(n, 0); + VECTOR_INDEX(*buf, i+1) = GetByte(n, 1); + VECTOR_INDEX(*buf, i+2) = GetByte(n, 2); } const char* script_op2name(int op) { @@ -606,21 +588,26 @@ int script_add_str(const char* p) return script->str_num++; } -/// Appends 1 byte to the script buffer. +/** + * Appends 1 byte to the script buffer. + * + * @param a The byte to append. + */ void add_scriptb(int a) { - if( script->pos+1 >= script->size ) - { - script->size += SCRIPT_BLOCK_SIZE; - RECREATE(script->buf,unsigned char,script->size); - } - script->buf[script->pos++] = (uint8)(a); + VECTOR_ENSURE(script->buf, 1, SCRIPT_BLOCK_SIZE); + VECTOR_PUSH(script->buf, (uint8)a); } -/// Appends a c_op value to the script buffer. -/// The value is variable-length encoded into 8-bit blocks. -/// The encoding scheme is ( 01?????? )* 00??????, LSB first. -/// All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries). +/** + * Appends a c_op value to the script buffer. + * + * The value is variable-length encoded into 8-bit blocks. + * The encoding scheme is ( 01?????? )* 00??????, LSB first. + * All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries). + * + * @param a The value to append. + */ void add_scriptc(int a) { while( a >= 0x40 ) @@ -632,10 +619,15 @@ void add_scriptc(int a) script->addb(a); } -/// Appends an integer value to the script buffer. -/// The value is variable-length encoded into 8-bit blocks. -/// The encoding scheme is ( 11?????? )* 10??????, LSB first. -/// All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries). +/** + * Appends an integer value to the script buffer. + * + * The value is variable-length encoded into 8-bit blocks. + * The encoding scheme is ( 11?????? )* 10??????, LSB first. + * All blocks but the last hold 7 bits of data, topmost bit is always 1 (carries). + * + * @param a The value to append. + */ void add_scripti(int a) { while( a >= 0x40 ) @@ -646,11 +638,11 @@ void add_scripti(int a) script->addb(a|0x80); } -/// Appends a script->str_data object (label/function/variable/integer) to the script buffer. - -/// -/// @param l The id of the script->str_data entry -// Maximum up to 16M +/** + * Appends a script->str_data object (label/function/variable/integer) to the script buffer. + * + * @param l The id of the script->str_data entry (Maximum up to 16M) + */ void add_scriptl(int l) { int backpatch = script->str_data[l].backpatch; @@ -667,7 +659,7 @@ void add_scriptl(int l) case C_USERFUNC: // Embedded data backpatch there is a possibility of label script->addc(C_NAME); - script->str_data[l].backpatch = script->pos; + script->str_data[l].backpatch = VECTOR_LENGTH(script->buf); script->addb(backpatch); script->addb(backpatch>>8); script->addb(backpatch>>16); @@ -705,9 +697,9 @@ void set_label(int l,int pos, const char* script_pos) script->str_data[l].type=(script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS); script->str_data[l].label=pos; for (i = script->str_data[l].backpatch; i >= 0 && i != 0x00ffffff; ) { - int next = GETVALUE(script->buf,i); - script->buf[i-1]=(script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS); - SETVALUE(script->buf,i,pos); + int next = GETVALUE(&script->buf, i); + VECTOR_INDEX(script->buf, i-1) = (script->str_data[l].type == C_USERFUNC ? C_USERFUNC_POS : C_POS); + SETVALUE(&script->buf, i, pos); i = next; } } @@ -811,26 +803,25 @@ const char* parse_callfunc(const char* p, int require_paren, int is_custom) char *arg = NULL; char null_arg = '\0'; int func; - bool nested_call = false, macro = false; + bool macro = false; // is need add check for arg null pointer below? func = script->add_word(p); - if( script->str_data[func].type == C_FUNC ) { - /** only when unset (-1), valid values are >= 0 **/ - if( script->syntax.last_func == -1 ) - script->syntax.last_func = script->str_data[func].val; - else { //Nested function call - script->syntax.nested_call++; - nested_call = true; - - if( script->str_data[func].val == script->buildin_lang_macro_offset ) { + if (script->str_data[func].type == C_FUNC) { + script->syntax.nested_call++; + if (script->syntax.last_func != -1) { + if (script->str_data[func].val == script->buildin_lang_macro_offset) { script->syntax.lang_macro_active = true; macro = true; + } else if (script->str_data[func].val == script->buildin_lang_macro_fmtstring_offset) { + script->syntax.lang_macro_fmtstring_active = true; + macro = true; } } if( !macro ) { // buildin function + script->syntax.last_func = script->str_data[func].val; script->addl(func); script->addc(C_ARG); } @@ -919,18 +910,17 @@ const char* parse_callfunc(const char* p, int require_paren, int is_custom) disp_error_message("parse_callfunc: expected ')' to close argument list",p); ++p; - if( script->str_data[func].val == script->buildin_lang_macro_offset ) + if (script->str_data[func].val == script->buildin_lang_macro_offset) script->syntax.lang_macro_active = false; + else if (script->str_data[func].val == script->buildin_lang_macro_fmtstring_offset) + script->syntax.lang_macro_fmtstring_active = false; } - if( nested_call ) - script->syntax.nested_call--; - - if( !script->syntax.nested_call ) - script->syntax.last_func = -1; - - if( !macro ) + if (!macro) { + if (0 == --script->syntax.nested_call) + script->syntax.last_func = -1; script->addc(C_FUNC); + } return p; } @@ -942,7 +932,7 @@ void parse_nextline(bool first, const char* p) if( !first ) { script->addc(C_EOL); // mark end of line for stack cleanup - script->set_label(LABEL_NEXTLINE, script->pos, p); // fix up '-' labels + script->set_label(LABEL_NEXTLINE, VECTOR_LENGTH(script->buf), p); // fix up '-' labels } // initialize data for new '-' label fix up scheduling @@ -1066,6 +1056,8 @@ const char* parse_variable(const char* p) } // push the set function onto the stack + script->syntax.nested_call++; + script->syntax.last_func = script->str_data[script->buildin_set_ref].val; script->addl(script->buildin_set_ref); script->addc(C_ARG); @@ -1117,6 +1109,8 @@ const char* parse_variable(const char* p) // close the script by appending the function operator script->addc(C_FUNC); + if (--script->syntax.nested_call == 0) + script->syntax.last_func = -1; // push the buffer from the method return p; @@ -1159,13 +1153,19 @@ bool is_number(const char *p) { } /** + * Duplicates a script string into the script string list. * - **/ -int script_string_dup(char *str) { - size_t len = strlen(str); + * Grows the script string list as needed. + * + * @param str The string to insert. + * @return the string position in the script string list. + */ +int script_string_dup(char *str) +{ + int len = (int)strlen(str); int pos = script->string_list_pos; - while( pos+len+1 >= script->string_list_size ) { + while (pos+len+1 >= script->string_list_size) { script->string_list_size += (1024*1024)/2; RECREATE(script->string_list,char,script->string_list_size); } @@ -1179,231 +1179,194 @@ int script_string_dup(char *str) { /*========================================== * Analysis section *------------------------------------------*/ -const char* parse_simpleexpr(const char *p) +const char *parse_simpleexpr(const char *p) { p=script->skip_space(p); - if(*p==';' || *p==',') + if (*p == ';' || *p == ',') disp_error_message("parse_simpleexpr: unexpected end of expression",p); - if(*p=='(') { - int i = script->syntax.curly_count-1; - if (i >= 0 && script->syntax.curly[i].type == TYPE_ARGLIST) - ++script->syntax.curly[i].count; - p=script->parse_subexpr(p+1,-1); - p=script->skip_space(p); - if( (i=script->syntax.curly_count-1) >= 0 && script->syntax.curly[i].type == TYPE_ARGLIST - && script->syntax.curly[i].flag == ARGLIST_UNDEFINED && --script->syntax.curly[i].count == 0 - ) { - if( *p == ',' ) { - script->syntax.curly[i].flag = ARGLIST_PAREN; - return p; - } else { - script->syntax.curly[i].flag = ARGLIST_NO_PAREN; - } - } - if( *p != ')' ) - disp_error_message("parse_simpleexpr: unmatched ')'",p); - ++p; - } else if(is_number(p)) { - char *np; - long long lli; - while(*p == '0' && ISDIGIT(p[1])) p++; // Skip leading zeros, we don't support octal literals - lli=strtoll(p,&np,0); - if( lli < INT_MIN ) { - lli = INT_MIN; - script->disp_warning_message("parse_simpleexpr: underflow detected, capping value to INT_MIN",p); - } else if( lli > INT_MAX ) { - lli = INT_MAX; - script->disp_warning_message("parse_simpleexpr: overflow detected, capping value to INT_MAX",p); - } - script->addi((int)lli); // Cast is safe, as it's already been checked for overflows - p=np; - } else if(*p=='"') { - struct string_translation *st = NULL; - const char *start_point = p; - bool duplicate = true; - struct script_string_buf *sbuf = &script->parse_simpleexpr_str; - - do { - p++; - while( *p && *p != '"' ) { - if( (unsigned char)p[-1] <= 0x7e && *p == '\\' ) { - char buf[8]; - size_t len = sv->skip_escaped_c(p) - p; - size_t n = sv->unescape_c(buf, p, len); - if( n != 1 ) - ShowDebug("parse_simpleexpr: unexpected length %d after unescape (\"%.*s\" -> %.*s)\n", (int)n, (int)len, p, (int)n, buf); - p += len; - script_string_buf_addb(sbuf, *buf); - continue; - } else if( *p == '\n' ) { - disp_error_message("parse_simpleexpr: unexpected newline @ string",p); - } - script_string_buf_addb(sbuf, *p++); - } - if(!*p) - disp_error_message("parse_simpleexpr: unexpected end of file @ string",p); - p++; //'"' - p = script->skip_space(p); - } while( *p && *p == '"' ); - - script_string_buf_addb(sbuf, 0); - - if (!(script->syntax.translation_db && (st = strdb_get(script->syntax.translation_db, sbuf->ptr)) != NULL)) { - script->addc(C_STR); - - if( script->pos+sbuf->pos >= script->size ) { - do { - script->size += SCRIPT_BLOCK_SIZE; - } while( script->pos+sbuf->pos >= script->size ); - RECREATE(script->buf,unsigned char,script->size); - } + if (*p == '(') { + return script->parse_simpleexpr_paren(p); + } else if (is_number(p)) { + return script->parse_simpleexpr_number(p); + } else if(*p == '"') { + return script->parse_simpleexpr_string(p); + } else { + return script->parse_simpleexpr_name(p); + } +} - memcpy(script->buf+script->pos, sbuf->ptr, sbuf->pos); - script->pos += sbuf->pos; +const char *parse_simpleexpr_paren(const char *p) +{ + int i = script->syntax.curly_count - 1; + if (i >= 0 && script->syntax.curly[i].type == TYPE_ARGLIST) + ++script->syntax.curly[i].count; + p = script->parse_subexpr(p + 1, -1); + p = script->skip_space(p); + if ((i = script->syntax.curly_count - 1) >= 0 + && script->syntax.curly[i].type == TYPE_ARGLIST + && script->syntax.curly[i].flag == ARGLIST_UNDEFINED + && --script->syntax.curly[i].count == 0 + ) { + if (*p == ',') { + script->syntax.curly[i].flag = ARGLIST_PAREN; + return p; } else { - int expand = sizeof(int) + sizeof(uint8); - unsigned char j; - unsigned int st_cursor = 0; + script->syntax.curly[i].flag = ARGLIST_NO_PAREN; + } + } + if (*p != ')') + disp_error_message("parse_simpleexpr: unmatched ')'", p); - script->addc(C_LSTR); + return p + 1; +} - expand += (sizeof(char*) + sizeof(uint8)) * st->translations; +const char *parse_simpleexpr_number(const char *p) +{ + char *np = NULL; + long long lli; - while( script->pos+expand >= script->size ) { - script->size += SCRIPT_BLOCK_SIZE; - RECREATE(script->buf,unsigned char,script->size); - } + while (*p == '0' && ISDIGIT(p[1])) + p++; // Skip leading zeros, we don't support octal literals - *((int *)(&script->buf[script->pos])) = st->string_id; - *((uint8 *)(&script->buf[script->pos + sizeof(int)])) = st->translations; + lli = strtoll(p, &np, 0); + if (lli < INT_MIN) { + lli = INT_MIN; + script->disp_warning_message("parse_simpleexpr: underflow detected, capping value to INT_MIN", p); + } else if (lli > INT_MAX) { + lli = INT_MAX; + script->disp_warning_message("parse_simpleexpr: overflow detected, capping value to INT_MAX", p); + } + script->addi((int)lli); // Cast is safe, as it's already been checked for overflows - script->pos += sizeof(int) + sizeof(uint8); + return np; +} - for(j = 0; j < st->translations; j++) { - *((uint8 *)(&script->buf[script->pos])) = RBUFB(st->buf, st_cursor); - *((char **)(&script->buf[script->pos+sizeof(uint8)])) = &st->buf[st_cursor + sizeof(uint8)]; - script->pos += sizeof(char*) + sizeof(uint8); - st_cursor += sizeof(uint8); - while(st->buf[st_cursor++]); - st_cursor += sizeof(uint8); - } - } +const char *parse_simpleexpr_string(const char *p) +{ + const char *start_point = p; - /* When exporting we don't know what is a translation and what isn't */ - if( script->lang_export_fp && sbuf->pos > 1 ) {//sbuf->pos will always be at least 1 because of the '\0' - if( !script->syntax.strings ) { - script->syntax.strings = strdb_alloc(DB_OPT_DUP_KEY|DB_OPT_ALLOW_NULL_DATA, 0); + do { + p++; + while (*p != '\0' && *p != '"') { + if ((unsigned char)p[-1] <= 0x7e && *p == '\\') { + char buf[8]; + size_t len = sv->skip_escaped_c(p) - p; + size_t n = sv->unescape_c(buf, p, len); + if (n != 1) + ShowDebug("parse_simpleexpr: unexpected length %d after unescape (\"%.*s\" -> %.*s)\n", (int)n, (int)len, p, (int)n, buf); + p += len; + VECTOR_ENSURE(script->parse_simpleexpr_strbuf, 1, 512); + VECTOR_PUSH(script->parse_simpleexpr_strbuf, buf[0]); + continue; } - - if( !strdb_exists(script->syntax.strings,sbuf->ptr) ) { - strdb_put(script->syntax.strings, sbuf->ptr, NULL); - duplicate = false; + if (*p == '\n') { + disp_error_message("parse_simpleexpr: unexpected newline @ string", p); } + VECTOR_ENSURE(script->parse_simpleexpr_strbuf, 1, 512); + VECTOR_PUSH(script->parse_simpleexpr_strbuf, *p++); } + if (*p == '\0') + disp_error_message("parse_simpleexpr: unexpected end of file @ string", p); + p++; //'"' + p = script->skip_space(p); + } while (*p != '\0' && *p == '"'); - if( script->lang_export_fp && !duplicate && - ( ( ( script->syntax.last_func == script->buildin_mes_offset || - script->syntax.last_func == script->buildin_select_offset ) && !script->syntax.nested_call - ) || script->syntax.lang_macro_active ) ) { - const char *line_start = start_point; - const char *line_end = start_point; - struct script_string_buf *lbuf = &script->lang_export_line_buf; - struct script_string_buf *ubuf = &script->lang_export_unescaped_buf; - size_t line_length, cursor; + VECTOR_ENSURE(script->parse_simpleexpr_strbuf, 1, 512); + VECTOR_PUSH(script->parse_simpleexpr_strbuf, '\0'); - while( line_start > script->parser_current_src ) { - if( *line_start != '\n' ) - line_start--; - else - break; - } + script->add_translatable_string(&script->parse_simpleexpr_strbuf, start_point); - while( *line_end != '\n' && *line_end != '\0' ) - line_end++; + VECTOR_TRUNCATE(script->parse_simpleexpr_strbuf); - line_length = (size_t)(line_end - line_start); - if( line_length > 0 ) { - script_string_buf_ensure(lbuf,line_length + 1); + return p; +} - memcpy(lbuf->ptr, line_start, line_length); - lbuf->pos = line_length; - script_string_buf_addb(lbuf, 0); +const char *parse_simpleexpr_name(const char *p) +{ + int l; + const char *pv = NULL; - normalize_name(lbuf->ptr, "\r\n\t "); - } + // label , register , function etc + if (script->skip_word(p) == p) + disp_error_message("parse_simpleexpr: unexpected character", p); - for(cursor = 0; cursor < sbuf->pos; cursor++) { - if( sbuf->ptr[cursor] == '"' ) - script_string_buf_addb(ubuf, '\\'); - script_string_buf_addb(ubuf, sbuf->ptr[cursor]); - } - script_string_buf_addb(ubuf, 0); - - fprintf(script->lang_export_fp, "#: %s\n" - "# %s\n" - "msgctxt \"%s\"\n" - "msgid \"%s\"\n" - "msgstr \"\"\n", - script->parser_current_file ? script->parser_current_file : "Unknown File", - lbuf->ptr, - script->parser_current_npc_name ? script->parser_current_npc_name : "Unknown NPC", - ubuf->ptr - ); - lbuf->pos = 0; - ubuf->pos = 0; + l = script->add_word(p); + if (script->str_data[l].type == C_FUNC || script->str_data[l].type == C_USERFUNC || script->str_data[l].type == C_USERFUNC_POS) { + return script->parse_callfunc(p,1,0); +#ifdef SCRIPT_CALLFUNC_CHECK + } else { + const char *name = script->get_str(l); + if (strdb_get(script->userfunc_db,name) != NULL) { + return script->parse_callfunc(p, 1, 1); } - sbuf->pos = 0; +#endif + } + + if ((pv = script->parse_variable(p)) != NULL) { + // successfully processed a variable assignment + return pv; + } + + if (script->str_data[l].type == C_INT && script->str_data[l].deprecated) { + disp_warning_message("This constant is deprecated and it will be removed in a future version. Please see the script documentation and constants.conf for an alternative.\n", p); + } + + p = script->skip_word(p); + if (*p == '[') { + // array(name[i] => getelementofarray(name,i) ) + script->addl(script->buildin_getelementofarray_ref); + script->addc(C_ARG); + script->addl(l); + + p = script->parse_subexpr(p + 1, -1); + p = script->skip_space(p); + if (*p != ']') + disp_error_message("parse_simpleexpr: unmatched ']'", p); + ++p; + script->addc(C_FUNC); } else { - int l; - const char* pv; + script->addl(l); + } - // label , register , function etc - if(script->skip_word(p)==p) - disp_error_message("parse_simpleexpr: unexpected character",p); + return p; +} - l=script->add_word(p); - if( script->str_data[l].type == C_FUNC || script->str_data[l].type == C_USERFUNC || script->str_data[l].type == C_USERFUNC_POS) { - return script->parse_callfunc(p,1,0); -#ifdef SCRIPT_CALLFUNC_CHECK - } else { - const char* name = script->get_str(l); - if( strdb_get(script->userfunc_db,name) != NULL ) { - return script->parse_callfunc(p,1,1); - } -#endif - } +void script_add_translatable_string(const struct script_string_buf *string, const char *start_point) +{ + struct string_translation *st = NULL; - if( (pv = script->parse_variable(p)) ) { - // successfully processed a variable assignment - return pv; - } + if (script->syntax.translation_db == NULL + || (st = strdb_get(script->syntax.translation_db, VECTOR_DATA(*string))) == NULL) { + script->addc(C_STR); - if (script->str_data[l].type == C_INT && script->str_data[l].deprecated) { - disp_warning_message("This constant is deprecated and it will be removed in a future version. Please see the script documentation and constants.conf for an alternative.\n", p); - } + VECTOR_ENSURE(script->buf, VECTOR_LENGTH(*string), SCRIPT_BLOCK_SIZE); - p=script->skip_word(p); - if( *p == '[' ) { - // array(name[i] => getelementofarray(name,i) ) - script->addl(script->buildin_getelementofarray_ref); - script->addc(C_ARG); - script->addl(l); + VECTOR_PUSHARRAY(script->buf, VECTOR_DATA(*string), VECTOR_LENGTH(*string)); + } else { + unsigned char u; + int st_cursor = 0; - p=script->parse_subexpr(p+1,-1); - p=script->skip_space(p); - if( *p != ']' ) - disp_error_message("parse_simpleexpr: unmatched ']'",p); - ++p; - script->addc(C_FUNC); - } else { - script->addl(l); - } + script->addc(C_LSTR); - } + VECTOR_ENSURE(script->buf, (int)(sizeof(st->string_id) + sizeof(st->translations)), SCRIPT_BLOCK_SIZE); + VECTOR_PUSHARRAY(script->buf, (void *)&st->string_id, sizeof(st->string_id)); + VECTOR_PUSHARRAY(script->buf, (void *)&st->translations, sizeof(st->translations)); - return p; + for (u = 0; u != st->translations; u++) { + struct string_translation_entry *entry = (void *)(st->buf+st_cursor); + char *stringptr = &entry->string[0]; + st_cursor += sizeof(*entry); + VECTOR_ENSURE(script->buf, (int)(sizeof(entry->lang_id) + sizeof(char *)), SCRIPT_BLOCK_SIZE); + VECTOR_PUSHARRAY(script->buf, (void *)&entry->lang_id, sizeof(entry->lang_id)); + VECTOR_PUSHARRAY(script->buf, (void *)&stringptr, sizeof(stringptr)); + st_cursor += sizeof(uint8); // FIXME: What are we skipping here? + while (st->buf[st_cursor++] != 0) + (void)0; // Skip string + st_cursor += sizeof(uint8); // FIXME: What are we skipping here? + } + } } /*========================================== @@ -1582,7 +1545,7 @@ const char* parse_curly_close(const char* p) // You are here labeled sprintf(label,"__SW%x_%x", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count); l=script->add_str(label); - script->set_label(l,script->pos, p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); if(script->syntax.curly[pos].flag) { //Exists default @@ -1595,7 +1558,7 @@ const char* parse_curly_close(const char* p) // Label end sprintf(label,"__SW%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos, p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); linkdb_final(&script->syntax.curly[pos].case_label); // free the list of case label script->syntax.curly_count--; //Closing decision if, for , while @@ -1674,7 +1637,7 @@ const char* parse_syntax(const char* p) // You are here labeled sprintf(label,"__SW%x_%x", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count); l=script->add_str(label); - script->set_label(l,script->pos, p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); } //Decision statement switch p = script->skip_space(p2); @@ -1714,7 +1677,7 @@ const char* parse_syntax(const char* p) // Label after the completion of FALLTHRU sprintf(label, "__SW%x_%xJ", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); } // check duplication of case label [Rayce] if(linkdb_search(&script->syntax.curly[pos].case_label, (void*)h64BPTRSIZE(v)) != NULL) @@ -1781,7 +1744,7 @@ const char* parse_syntax(const char* p) } sprintf(label, "__SW%x_%x", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); // Skip to the next link w/o condition sprintf(label, "goto __SW%x_%x;", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count + 1); @@ -1792,7 +1755,7 @@ const char* parse_syntax(const char* p) // The default label sprintf(label, "__SW%x_DEF", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly[script->syntax.curly_count - 1].flag = 1; script->syntax.curly[pos].count++; @@ -1810,7 +1773,7 @@ const char* parse_syntax(const char* p) // Label of the (do) form here sprintf(label, "__DO%x_BGN", (unsigned int)script->syntax.curly[script->syntax.curly_count].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly_count++; return p; } @@ -1841,7 +1804,7 @@ const char* parse_syntax(const char* p) // Form the start of label decision sprintf(label, "__FR%x_J", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); p=script->skip_space(p); if(*p == ';') { @@ -1870,7 +1833,7 @@ const char* parse_syntax(const char* p) // Labels to form the next loop sprintf(label, "__FR%x_NXT", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); // Process the next time you enter the loop // A ')' last for; flag to be treated as' @@ -1889,7 +1852,7 @@ const char* parse_syntax(const char* p) // Loop start labeling sprintf(label, "__FR%x_BGN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); return p; } else if( p2 - p == 8 && strncmp(p, "function", 8) == 0 ) { // internal script function @@ -1939,9 +1902,9 @@ const char* parse_syntax(const char* p) if( script->str_data[l].type == C_NOP || script->str_data[l].type == C_USERFUNC )// register only, if the name was not used by something else { script->str_data[l].type = C_USERFUNC; - script->set_label(l, script->pos, p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); if( script->parse_options&SCRIPT_USE_LABEL_DB ) - script->label_add(l,script->pos); + script->label_add(l, VECTOR_LENGTH(script->buf)); } else disp_error_message("parse_syntax:function: function name is invalid", func_name); @@ -2021,7 +1984,7 @@ const char* parse_syntax(const char* p) // Form the start of label decision sprintf(label, "__WL%x_NXT", (unsigned int)script->syntax.curly[script->syntax.curly_count].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); // Skip to the end point if the condition is false sprintf(label, "__WL%x_FIN", (unsigned int)script->syntax.curly[script->syntax.curly_count].index); @@ -2078,7 +2041,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // Put the label of the location sprintf(label, "__IF%x_%x", (unsigned int)script->syntax.curly[pos].index, (unsigned int)script->syntax.curly[pos].count); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly[pos].count++; p = script->skip_space(p); @@ -2116,7 +2079,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // Put the label of the final location sprintf(label, "__IF%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); if(script->syntax.curly[pos].flag == 1) { // Because the position of the pointer is the same if not else for this return bp; @@ -2129,7 +2092,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // (Come here continue) to form the label here sprintf(label, "__DO%x_NXT", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); } // Skip to the end point if the condition is false @@ -2164,7 +2127,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // Form label of the end point conditions sprintf(label, "__DO%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); p = script->skip_space(p); if(*p != ';') { disp_error_message("parse_syntax: need ';'",p); @@ -2186,7 +2149,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // End for labeling sprintf(label, "__FR%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly_count--; return p; } else if(script->syntax.curly[pos].type == TYPE_WHILE) { @@ -2202,7 +2165,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // End while labeling sprintf(label, "__WL%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly_count--; return p; } else if(script->syntax.curly[pos].type == TYPE_USERFUNC) { @@ -2215,7 +2178,7 @@ const char* parse_syntax_close_sub(const char* p,int* flag) // Put the label of the location sprintf(label, "__FN%x_FIN", (unsigned int)script->syntax.curly[pos].index); l=script->add_str(label); - script->set_label(l,script->pos,p); + script->set_label(l, VECTOR_LENGTH(script->buf), p); script->syntax.curly_count--; return p; } else { @@ -2544,9 +2507,6 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o script->parse_cleanup_timer_id = timer->add(timer->gettick() + 10, script->parse_cleanup_timer, 0, 0); } - if( script->syntax.strings ) /* used only when generating translation file */ - db_destroy(script->syntax.strings); - memset(&script->syntax,0,sizeof(script->syntax)); script->syntax.last_func = -1;/* as valid values are >= 0 */ if( script->parser_current_npc_name ) { @@ -2556,11 +2516,7 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o script->syntax.translation_db = strdb_get(script->translation_db, script->parser_current_npc_name); } - if( !script->buf ) { - script->buf = (unsigned char *)aMalloc(SCRIPT_BLOCK_SIZE*sizeof(unsigned char)); - script->size = SCRIPT_BLOCK_SIZE; - } - script->pos=0; + VECTOR_TRUNCATE(script->buf); script->parse_nextline(true, NULL); // who called parse_script is responsible for clearing the database after using it, but just in case... lets clear it here @@ -2574,7 +2530,7 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o if( script->error_report ) script->error(src,file,line,script->error_msg,script->error_pos); aFree( script->error_msg ); - script->pos = 0; + VECTOR_TRUNCATE(script->buf); for(i=LABEL_START;i<script->str_num;i++) if(script->str_data[i].type == C_NOP) script->str_data[i].type = C_NAME; for(i=0; i<size; i++) @@ -2594,9 +2550,9 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o p=script->skip_space(p); if( options&SCRIPT_IGNORE_EXTERNAL_BRACKETS ) {// does not require brackets around the script - if( *p == '\0' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT) ) - {// empty script and can return NULL - script->pos = 0; + if (*p == '\0' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT)) { + // empty script and can return NULL + VECTOR_TRUNCATE(script->buf); #ifdef ENABLE_CASE_CHECK script->local_casecheck.clear(); script->parser_current_src = NULL; @@ -2614,9 +2570,9 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o if (retval) *retval = EXIT_FAILURE; } p = script->skip_space(p+1); - if( *p == '}' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT) ) - {// empty script and can return NULL - script->pos = 0; + if (*p == '}' && !(options&SCRIPT_RETURN_EMPTY_SCRIPT)) { + // empty script and can return NULL + VECTOR_TRUNCATE(script->buf); #ifdef ENABLE_CASE_CHECK script->local_casecheck.clear(); script->parser_current_src = NULL; @@ -2648,9 +2604,9 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o tmpp=script->skip_space(script->skip_word(p)); if(*tmpp==':' && !(strncmp(p,"default:",8) == 0 && p + 7 == tmpp)) { i=script->add_word(p); - script->set_label(i,script->pos,p); + script->set_label(i, VECTOR_LENGTH(script->buf), p); if( script->parse_options&SCRIPT_USE_LABEL_DB ) - script->label_add(i,script->pos); + script->label_add(i, VECTOR_LENGTH(script->buf)); p=tmpp+1; p=script->skip_space(p); continue; @@ -2672,8 +2628,8 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o script->str_data[i].type=C_NAME; script->str_data[i].label=i; for (j = script->str_data[i].backpatch; j >= 0 && j != 0x00ffffff; ) { - int next = GETVALUE(script->buf,j); - SETVALUE(script->buf,j,i); + int next = GETVALUE(&script->buf, j); + SETVALUE(&script->buf, j, i); j = next; } } else if(script->str_data[i].type == C_USERFUNC) { @@ -2690,37 +2646,39 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o } #ifdef SCRIPT_DEBUG_DISP - for(i=0;i<script->pos;i++) { - if((i&15)==0) ShowMessage("%04x : ",i); - ShowMessage("%02x ",script->buf[i]); - if((i&15)==15) ShowMessage("\n"); + for (i = 0; i < VECTOR_LENGTH(script->buf); i++) { + if ((i&15) == 0) + ShowMessage("%04x : ",i); + ShowMessage("%02x ", VECTOR_INDEX(script->buf, i)); + if ((i&15) == 15) + ShowMessage("\n"); } ShowMessage("\n"); #endif #ifdef SCRIPT_DEBUG_DISASM i = 0; - while(i < script->pos) { - int j = i; - c_op op = script->get_com(script->buf,&i); + while (i < VECTOR_LENGTH(script->buf)) { + c_op op = script->get_com(&script->buf, &i); + int j = i; // Note: i is modified in the line above. ShowMessage("%06x %s", i, script->op2name(op)); - j = i; - switch(op) { + + switch (op) { case C_INT: - ShowMessage(" %d", script->get_num(script->buf,&i)); + ShowMessage(" %d", script->get_num(&script->buf, &i)); break; case C_POS: - ShowMessage(" 0x%06x", *(int*)(script->buf+i)&0xffffff); + ShowMessage(" 0x%06x", *(int*)(&VECTOR_INDEX(script->buf, i))&0xffffff); i += 3; break; case C_NAME: - j = (*(int*)(script->buf+i)&0xffffff); + j = (*(int*)(&VECTOR_INDEX(script->buf, i))&0xffffff); ShowMessage(" %s", ( j == 0xffffff ) ? "?? unknown ??" : script->get_str(j)); i += 3; break; case C_STR: - j = (int)strlen((char*)script->buf + i); - ShowMessage(" %s", script->buf + i); + j = (int)strlen((char*)&VECTOR_INDEX(script->buf, i)); + ShowMessage(" %s", &VECTOR_INDEX(script->buf, i)); i += j+1; break; } @@ -2729,9 +2687,9 @@ struct script_code* parse_script(const char *src,const char *file,int line,int o #endif CREATE(code,struct script_code,1); - code->script_buf = (unsigned char *)aMalloc(script->pos*sizeof(unsigned char)); - memcpy(code->script_buf, script->buf, script->pos); - code->script_size = script->pos; + VECTOR_INIT(code->script_buf); + VECTOR_ENSURE(code->script_buf, VECTOR_LENGTH(script->buf), 1); + VECTOR_PUSHARRAY(code->script_buf, VECTOR_DATA(script->buf), VECTOR_LENGTH(script->buf)); code->local.vars = NULL; code->local.arrays = NULL; #ifdef ENABLE_CASE_CHECK @@ -3624,7 +3582,7 @@ void script_free_code(struct script_code* code) script->free_vars(code->local.vars); if (code->local.arrays) code->local.arrays->destroy(code->local.arrays,script->array_free_db); - aFree(code->script_buf); + VECTOR_CLEAR(code->script_buf); aFree(code); } @@ -3749,32 +3707,32 @@ void script_add_pending_ref(struct script_state *st, struct reg_db *ref) { /*========================================== * Read command *------------------------------------------*/ -c_op get_com(unsigned char *scriptbuf,int *pos) +c_op get_com(const struct script_buf *scriptbuf, int *pos) { int i = 0, j = 0; - if(scriptbuf[*pos]>=0x80) { + if (VECTOR_INDEX(*scriptbuf, *pos) >= 0x80) { return C_INT; } - while(scriptbuf[*pos]>=0x40) { - i=scriptbuf[(*pos)++]<<j; + while (VECTOR_INDEX(*scriptbuf, *pos) >= 0x40) { + i = VECTOR_INDEX(*scriptbuf, (*pos)++) << j; j+=6; } - return (c_op)(i+(scriptbuf[(*pos)++]<<j)); + return (c_op)(i+(VECTOR_INDEX(*scriptbuf, (*pos)++)<<j)); } /*========================================== * Income figures *------------------------------------------*/ -int get_num(unsigned char *scriptbuf,int *pos) +int get_num(const struct script_buf *scriptbuf, int *pos) { int i,j; i=0; j=0; - while(scriptbuf[*pos]>=0xc0) { - i+=(scriptbuf[(*pos)++]&0x7f)<<j; + while (VECTOR_INDEX(*scriptbuf, *pos) >= 0xc0) { + i+= (VECTOR_INDEX(*scriptbuf, (*pos)++)&0x7f)<<j; j+=6; } - return i+((scriptbuf[(*pos)++]&0x7f)<<j); + return i+((VECTOR_INDEX(*scriptbuf, (*pos)++)&0x7f)<<j); } /// Ternary operators @@ -3834,7 +3792,7 @@ void op_2str(struct script_state* st, int op, const char* s1, const char* s2) pcre *compiled_regex; pcre_extra *extra_regex; const char *pcre_error, *pcre_match; - int pcre_erroroffset, offsetcount, i; + int pcre_erroroffset, offsetcount; int offsets[256*3]; // (max_capturing_groups+1)*3 compiled_regex = libpcre->compile(s2, 0, &pcre_error, &pcre_erroroffset, NULL); @@ -3875,8 +3833,9 @@ void op_2str(struct script_state* st, int op, const char* s1, const char* s2) return; } - if( op == C_RE_EQ ) { - for( i = 0; i < offsetcount; i++ ) { + if (op == C_RE_EQ) { + int i; + for (i = 0; i < offsetcount; i++) { libpcre->get_substring(s1, offsets, offsetcount, i, &pcre_match); mapreg->setregstr(reference_uid(script->add_str("$@regexmatch$"), i), pcre_match); libpcre->free_substring(pcre_match); @@ -4083,10 +4042,17 @@ void op_1(struct script_state* st, int op) /// /// @param st Script state whose stack arguments should be inspected. /// @param func Built-in function for which the arguments are intended. -void script_check_buildin_argtype(struct script_state* st, int func) +bool script_check_buildin_argtype(struct script_state* st, int func) { int idx, invalid = 0; - char* sf = script->buildin[script->str_data[func].val]; + char* sf; + if (script->str_data[func].val < 0 || script->str_data[func].val >= script->buildin_count) { + ShowDebug("Function: %s\n", script->get_str(func)); + ShowError("Script data corruption detected!\n"); + script->reportsrc(st); + return false; + } + sf = script->buildin[script->str_data[func].val]; for (idx = 2; script_hasdata(st, idx); idx++) { struct script_data* data = script_getdata(st, idx); @@ -4157,6 +4123,7 @@ void script_check_buildin_argtype(struct script_state* st, int func) ShowDebug("Function: %s\n", script->get_str(func)); script->reportsrc(st); } + return true; } /// Executes a buildin command. @@ -4194,7 +4161,11 @@ int run_func(struct script_state *st) } if( script->config.warn_func_mismatch_argtypes ) { - script->check_buildin_argtype(st, func); + if (script->check_buildin_argtype(st, func) == false) + { + st->state = END; + return 1; + } } if(script->str_data[func].func) { @@ -4393,7 +4364,7 @@ void run_script_main(struct script_state *st) { st->state = RUN; while( st->state == RUN ) { - enum c_op c = script->get_com(st->script->script_buf,&st->pos); + enum c_op c = script->get_com(&st->script->script_buf, &st->pos); switch(c) { case C_EOL: if( stack->defsp > stack->sp ) @@ -4402,27 +4373,29 @@ void run_script_main(struct script_state *st) { script->pop_stack(st, stack->defsp, stack->sp);// pop unused stack data. (unused return value) break; case C_INT: - script->push_val(stack,C_INT,script->get_num(st->script->script_buf,&st->pos),NULL); + script->push_val(stack,C_INT,script->get_num(&st->script->script_buf, &st->pos), NULL); break; case C_POS: case C_NAME: - script->push_val(stack,c,GETVALUE(st->script->script_buf,st->pos),NULL); + script->push_val(stack,c,GETVALUE(&st->script->script_buf, st->pos), NULL); st->pos+=3; break; case C_ARG: script->push_val(stack,c,0,NULL); break; case C_STR: - script->push_conststr(stack, (const char *)(st->script->script_buf+st->pos)); - while(st->script->script_buf[st->pos++]); + script->push_conststr(stack, (const char *)&VECTOR_INDEX(st->script->script_buf, st->pos)); + while (VECTOR_INDEX(st->script->script_buf, st->pos++) != 0) + (void)0; // Skip string break; case C_LSTR: { - int string_id = *((int *)(&st->script->script_buf[st->pos])); - uint8 translations = *((uint8 *)(&st->script->script_buf[st->pos+sizeof(int)])); struct map_session_data *lsd = NULL; - - st->pos += sizeof(int) + sizeof(uint8); + uint8 translations = 0; + int string_id = *((int *)(&VECTOR_INDEX(st->script->script_buf, st->pos))); + st->pos += sizeof(string_id); + translations = *((uint8 *)(&VECTOR_INDEX(st->script->script_buf, st->pos))); + st->pos += sizeof(translations); if( (!st->rid || !(lsd = map->id2sd(st->rid)) || !lsd->lang_id) && !map->default_lang_id ) script->push_conststr(stack, script->string_list+string_id); @@ -4431,7 +4404,7 @@ void run_script_main(struct script_state *st) { int offset = st->pos; for(k = 0; k < translations; k++) { - uint8 lang_id = *(uint8 *)(&st->script->script_buf[offset]); + uint8 lang_id = *(uint8 *)(&VECTOR_INDEX(st->script->script_buf, offset)); offset += sizeof(uint8); if( lang_id == wlang_id ) break; @@ -4440,7 +4413,7 @@ void run_script_main(struct script_state *st) { if (k == translations) script->push_conststr(stack, script->string_list+string_id); else - script->push_conststr(stack, *(const char**)(&st->script->script_buf[offset]) ); + script->push_conststr(stack, *(const char**)(&VECTOR_INDEX(st->script->script_buf, offset))); } st->pos += ( ( sizeof(char*) + sizeof(uint8) ) * translations ); } @@ -4854,9 +4827,6 @@ void do_final_script(void) script->clear_translations(false); script->parser_clean_leftovers(); - - if( script->lang_export_file ) - aFree(script->lang_export_file); } /** @@ -4878,7 +4848,7 @@ void script_load_translations(void) { const char *config_filename = "db/translations.conf"; // FIXME hardcoded name struct config_setting_t *translations = NULL; int i, size; - uint32 total = 0; + int total = 0; uint8 lang_id = 0, k; if (map->minimal) // No translations in minimal mode @@ -4915,24 +4885,22 @@ void script_load_translations(void) { for(i = 0; i < size; i++) { const char *translation_file = libconfig->setting_get_string_elem(translations, i); - script->load_translation(translation_file, ++lang_id, &total); + total += script->load_translation(translation_file, ++lang_id); } libconfig->destroy(&translations_conf); - if( total ) { - struct DBIterator *main_iter, *sub_iter; + if (total != 0) { + struct DBIterator *main_iter; struct DBMap *string_db; struct string_translation *st = NULL; - uint32 j = 0; - CREATE(script->translation_buf, char *, total); - script->translation_buf_size = total; + VECTOR_ENSURE(script->translation_buf, total, 1); main_iter = db_iterator(script->translation_db); - for( string_db = dbi_first(main_iter); dbi_exists(main_iter); string_db = dbi_next(main_iter) ) { - sub_iter = db_iterator(string_db); - for( st = dbi_first(sub_iter); dbi_exists(sub_iter); st = dbi_next(sub_iter) ) { - script->translation_buf[j++] = st->buf; + for (string_db = dbi_first(main_iter); dbi_exists(main_iter); string_db = dbi_next(main_iter)) { + struct DBIterator *sub_iter = db_iterator(string_db); + for (st = dbi_first(sub_iter); dbi_exists(sub_iter); st = dbi_next(sub_iter)) { + VECTOR_PUSH(script->translation_buf, st->buf); } dbi_destroy(sub_iter); } @@ -4954,52 +4922,75 @@ void script_load_translations(void) { } /** + * Generates a language name from a translation filename. * - **/ -const char * script_get_translation_file_name(const char *file) { - static char file_name[200]; - int i, len = (int)strlen(file), last_bar = -1, last_dot = -1; + * @param file The filename. + * @return The corresponding translation name. + */ +const char *script_get_translation_file_name(const char *file) +{ + const char *basename = NULL, *last_dot = NULL; - for(i = 0; i < len; i++) { - if( file[i] == '/' || file[i] == '\\' ) - last_bar = i; - else if ( file[i] == '.' ) - last_dot = i; + nullpo_retr("Unknown", file); + + basename = strrchr(file, '/');; +#ifdef WIN32 + { + const char *basename_windows = strrchr(file, '\\'); + if (basename_windows > basename) + basename = basename_windows; } +#endif // WIN32 + if (basename == NULL) + basename = file; + else + basename++; // Skip slash + Assert_retr("Unknown", *basename != '\0'); - if( last_bar != -1 || last_dot != -1 ) { - if( last_bar != -1 && last_dot < last_bar ) - last_dot = -1; - safestrncpy(file_name, file+(last_bar >= 0 ? last_bar+1 : 0), ( last_dot >= 0 ? ( last_bar >= 0 ? last_dot - last_bar : last_dot ) : sizeof(file_name) )); + last_dot = strrchr(basename, '.'); + if (last_dot != NULL) { + static char file_name[200]; + if (last_dot == basename) + return basename + 1; + + safestrncpy(file_name, basename, last_dot - basename + 1); return file_name; } - return file; + return basename; } /** - * Parses a individual translation file - **/ -void script_load_translation(const char *file, uint8 lang_id, uint32 *total) { - uint32 translations = 0; + * Parses an individual translation file. + * + * @param file The filename to parse. + * @param lang_id The language identifier. + * @return The amount of strings loaded. + */ +int script_load_translation(const char *file, uint8 lang_id) +{ + int translations = 0; char line[1024]; char msgctxt[NAME_LENGTH*2+1] = { 0 }; struct DBMap *string_db; size_t i; FILE *fp; - struct script_string_buf msgid = { 0 }, msgstr = { 0 }; + struct script_string_buf msgid, msgstr; if( !(fp = fopen(file,"rb")) ) { ShowError("load_translation: failed to open '%s' for reading\n",file); - return; + return 0; } + VECTOR_INIT(msgid); + VECTOR_INIT(msgstr); + script->add_language(script->get_translation_file_name(file)); if( lang_id >= atcommand->max_message_table ) atcommand->expand_message_table(); while(fgets(line, sizeof(line), fp)) { - size_t len = strlen(line), cursor = 0; + size_t len = strlen(line); if( len <= 1 ) continue; @@ -5008,6 +4999,7 @@ void script_load_translation(const char *file, uint8 lang_id, uint32 *total) { continue; if( strncasecmp(line,"msgctxt \"", 9) == 0 ) { + int cursor = 0; msgctxt[0] = '\0'; for(i = 9; i < len - 2; i++) { if( line[i] == '\\' && line[i+1] == '"' ) { @@ -5015,44 +5007,50 @@ void script_load_translation(const char *file, uint8 lang_id, uint32 *total) { i++; } else msgctxt[cursor] = line[i]; - if( ++cursor >= sizeof(msgctxt) - 1 ) + if (++cursor >= (int)sizeof(msgctxt) - 1) break; } msgctxt[cursor] = '\0'; } else if ( strncasecmp(line, "msgid \"", 7) == 0 ) { - msgid.pos = 0; + VECTOR_TRUNCATE(msgid); for(i = 7; i < len - 2; i++) { + VECTOR_ENSURE(msgid, 1, 512); if( line[i] == '\\' && line[i+1] == '"' ) { - script_string_buf_addb(&msgid, '"'); + VECTOR_PUSH(msgid, '"'); i++; - } else - script_string_buf_addb(&msgid, line[i]); + } else { + VECTOR_PUSH(msgid, line[i]); + } } - script_string_buf_addb(&msgid,0); + VECTOR_ENSURE(msgid, 1, 512); + VECTOR_PUSH(msgid, '\0'); } else if ( len > 9 && line[9] != '"' && strncasecmp(line, "msgstr \"",8) == 0 ) { - msgstr.pos = 0; + VECTOR_TRUNCATE(msgstr); for(i = 8; i < len - 2; i++) { + VECTOR_ENSURE(msgstr, 1, 512); if( line[i] == '\\' && line[i+1] == '"' ) { - script_string_buf_addb(&msgstr, '"'); + VECTOR_PUSH(msgstr, '"'); i++; - } else - script_string_buf_addb(&msgstr, line[i]); + } else { + VECTOR_PUSH(msgstr, line[i]); + } } - script_string_buf_addb(&msgstr,0); + VECTOR_ENSURE(msgstr, 1, 512); + VECTOR_PUSH(msgstr, '\0'); } - if( msgctxt[0] && msgid.pos > 1 && msgstr.pos > 1 ) { - size_t msgstr_len = msgstr.pos; + if( msgctxt[0] && VECTOR_LENGTH(msgid) > 1 && VECTOR_LENGTH(msgstr) > 1 ) { + int msgstr_len = VECTOR_LENGTH(msgstr); unsigned int inner_len = 1 + (uint32)msgstr_len + 1; //uint8 lang_id + msgstr_len + '\0' if( strcasecmp(msgctxt, "messages.conf") == 0 ) { int k; for(k = 0; k < MAX_MSG; k++) { - if( atcommand->msg_table[0][k] && strcmpi(atcommand->msg_table[0][k],msgid.ptr) == 0 ) { + if( atcommand->msg_table[0][k] && strcmpi(atcommand->msg_table[0][k], VECTOR_DATA(msgid)) == 0 ) { if( atcommand->msg_table[lang_id][k] ) aFree(atcommand->msg_table[lang_id][k]); - atcommand->msg_table[lang_id][k] = aStrdup(msgstr.ptr); + atcommand->msg_table[lang_id][k] = aStrdup(VECTOR_DATA(msgstr)); break; } } @@ -5064,33 +5062,33 @@ void script_load_translation(const char *file, uint8 lang_id, uint32 *total) { strdb_put(script->translation_db, msgctxt, string_db); } - if( !(st = strdb_get(string_db, msgid.ptr) ) ) { + if ((st = strdb_get(string_db, VECTOR_DATA(msgid))) == NULL) { CREATE(st, struct string_translation, 1); - st->string_id = script->string_dup(msgid.ptr); - strdb_put(string_db, msgid.ptr, st); + st->string_id = script->string_dup(VECTOR_DATA(msgid)); + strdb_put(string_db, VECTOR_DATA(msgid), st); } - RECREATE(st->buf, char, st->len + inner_len); + RECREATE(st->buf, uint8, st->len + inner_len); WBUFB(st->buf, st->len) = lang_id; - safestrncpy(WBUFP(st->buf, st->len + 1), msgstr.ptr, msgstr_len + 1); + safestrncpy(WBUFP(st->buf, st->len + 1), VECTOR_DATA(msgstr), msgstr_len + 1); st->translations++; st->len += inner_len; } msgctxt[0] = '\0'; - msgid.pos = msgstr.pos = 0; + VECTOR_TRUNCATE(msgid); + VECTOR_TRUNCATE(msgstr); translations++; } } - *total += translations; - fclose(fp); - script_string_buf_destroy(&msgid); - script_string_buf_destroy(&msgstr); + VECTOR_CLEAR(msgid); + VECTOR_CLEAR(msgstr); - ShowStatus("Done reading '"CL_WHITE"%u"CL_RESET"' translations in '"CL_WHITE"%s"CL_RESET"'.\n", translations, file); + ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' translations in '"CL_WHITE"%s"CL_RESET"'.\n", translations, file); + return translations; } /** @@ -5106,15 +5104,10 @@ void script_clear_translations(bool reload) { script->string_list_pos = 0; script->string_list_size = 0; - if( script->translation_buf ) { - for(i = 0; i < script->translation_buf_size; i++) { - aFree(script->translation_buf[i]); - } - aFree(script->translation_buf); + while (VECTOR_LENGTH(script->translation_buf) > 0) { + aFree(VECTOR_POP(script->translation_buf)); } - - script->translation_buf = NULL; - script->translation_buf_size = 0; + VECTOR_CLEAR(script->translation_buf); if( script->languages ) { for(i = 0; i < script->max_lang_id; i++) @@ -5156,26 +5149,16 @@ int script_translation_db_destroyer(union DBKey key, struct DBData *data, va_lis /** * **/ -void script_parser_clean_leftovers(void) { - if( script->buf ) - aFree(script->buf); - - script->buf = NULL; - script->size = 0; +void script_parser_clean_leftovers(void) +{ + VECTOR_CLEAR(script->buf); if( script->translation_db ) { script->translation_db->destroy(script->translation_db,script->translation_db_destroyer); script->translation_db = NULL; } - if( script->syntax.strings ) { /* used only when generating translation file */ - db_destroy(script->syntax.strings); - script->syntax.strings = NULL; - } - - script_string_buf_destroy(&script->parse_simpleexpr_str); - script_string_buf_destroy(&script->lang_export_line_buf); - script_string_buf_destroy(&script->lang_export_unescaped_buf); + VECTOR_CLEAR(script->parse_simpleexpr_strbuf); } /** @@ -5194,6 +5177,7 @@ int script_parse_cleanup_timer(int tid, int64 tick, int id, intptr_t data) { *------------------------------------------*/ void do_init_script(bool minimal) { script->parse_cleanup_timer_id = INVALID_TIMER; + VECTOR_INIT(script->parse_simpleexpr_strbuf); script->st_db = idb_alloc(DB_OPT_BASE); script->userfunc_db = strdb_alloc(DB_OPT_DUP_KEY,0); @@ -5280,6 +5264,232 @@ const char *script_getfuncname(struct script_state *st) { return NULL; } +/** + * Writes a string to a StringBuf by combining a format string and a set of + * arguments taken from the current script state (caller script function + * arguments). + * + * @param[in] st Script state (must have at least a string at index + * 'start'). + * @param[in] start Index of the format string argument. + * @param[out] out Output string buffer (managed by the caller, must be + * already initialized) + * @retval false if an error occurs. + */ +bool script_sprintf(struct script_state *st, int start, struct StringBuf *out) +{ + const char *format = NULL; + const char *p = NULL, *np = NULL; + char *buf = NULL; + int buf_len = 0; + int lastarg = start; + int argc = script_lastdata(st) + 1; + + Assert_retr(-1, start >= 2 && start <= argc); + Assert_retr(-1, script_hasdata(st, start)); + + p = format = script_getstr(st, start); + + /* + * format-string = "" / *(text / placeholder) + * placeholder = "%%" / "%n" / std-placeholder + * std-placeholder = "%" [pos-parameter] [flags] [width] [precision] [length] type + * pos-parameter = number "$" + * flags = *("-" / "+" / "0" / SP) + * width = number / ("*" [pos-parameter]) + * precision = "." (number / ("*" [pos-parameter])) + * length = "hh" / "h" / "l" / "ll" / "L" / "z" / "j" / "t" + * type = "d" / "i" / "u" / "f" / "F" / "e" / "E" / "g" / "G" / "x" / "X" / "o" / "s" / "c" / "p" / "a" / "A" + * number = digit-nonzero *DIGIT + * digit-nonzero = "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9" + */ + + while ((np = strchr(p, '%')) != NULL) { + bool flag_plus = false, flag_minus = false, flag_zero = false, flag_space = false; + bool positional_arg = false; + int width = 0, nextarg = lastarg + 1, thisarg = nextarg; + + if (p != np) { + int len = (int)(np - p + 1); + if (buf_len < len) { + RECREATE(buf, char, len); + buf_len = len; + } + safestrncpy(buf, p, len); + StrBuf->AppendStr(out, buf); + } + + p = np; + np++; + + // placeholder = "%%" ; (special case) + if (*np == '%') { + StrBuf->AppendStr(out, "%"); + p = np + 1; + continue; + } + // placeholder = "%n" ; (ignored) + if (*np == 'n') { + ShowWarning("script_sprintf: Format %%n not supported! Skipping...\n"); + script->reportsrc(st); + lastarg = nextarg; + p = np + 1; + continue; + } + + // std-placeholder = "%" [pos-parameter] [flags] [width] [precision] [length] type + + // pos-parameter = number "$" + if (ISDIGIT(*np) && *np != '0') { + const char *pp = np; + while (ISDIGIT(*pp)) + pp++; + if (*pp == '$') { + thisarg = atoi(np) + start; + positional_arg = true; + np = pp + 1; + } + } + + if (thisarg >= argc) { + ShowError("buildin_sprintf: Not enough arguments passed!\n"); + if (buf != NULL) + aFree(buf); + return false; + } + + // flags = *("-" / "+" / "0" / SP) + while (true) { + if (*np == '-') { + flag_minus = true; + } else if (*np == '+') { + flag_plus = true; + } else if (*np == ' ') { + flag_space = true; + } else if (*np == '0') { + flag_zero = true; + } else { + break; + } + np++; + } + + // width = number / ("*" [pos-parameter]) + if (ISDIGIT(*np)) { + width = atoi(np); + while (ISDIGIT(*np)) + np++; + } else if (*np == '*') { + bool positional_widtharg = false; + int width_arg; + np++; + // pos-parameter = number "$" + if (ISDIGIT(*np) && *np != '0') { + const char *pp = np; + while (ISDIGIT(*pp)) + pp++; + if (*pp == '$') { + width_arg = atoi(np) + start; + positional_widtharg = true; + np = pp + 1; + } + } + if (!positional_widtharg) { + width_arg = nextarg; + nextarg++; + if (!positional_arg) + thisarg++; + } + + if (width_arg >= argc || thisarg >= argc) { + ShowError("buildin_sprintf: Not enough arguments passed!\n"); + if (buf != NULL) + aFree(buf); + return false; + } + width = script_getnum(st, width_arg); + } + + // precision = "." (number / ("*" [pos-parameter])) ; (not needed/implemented) + + // length = "hh" / "h" / "l" / "ll" / "L" / "z" / "j" / "t" ; (not needed/implemented) + + // type = "d" / "i" / "u" / "f" / "F" / "e" / "E" / "g" / "G" / "x" / "X" / "o" / "s" / "c" / "p" / "a" / "A" + if (buf_len < 16) { + RECREATE(buf, char, 16); + buf_len = 16; + } + { + int i = 0; + memset(buf, '\0', buf_len); + buf[i++] = '%'; + if (flag_minus) + buf[i++] = '-'; + if (flag_plus) + buf[i++] = '+'; + else if (flag_space) // ignored if '+' is specified + buf[i++] = ' '; + if (flag_zero) + buf[i++] = '0'; + if (width > 0) + safesnprintf(buf + i, buf_len - i - 1, "%d", width); + } + buf[(int)strlen(buf)] = *np; + switch (*np) { + case 'd': + case 'i': + case 'u': + case 'x': + case 'X': + case 'o': + // Piggyback printf + StrBuf->Printf(out, buf, script_getnum(st, thisarg)); + break; + case 's': + // Piggyback printf + StrBuf->Printf(out, buf, script_getstr(st, thisarg)); + break; + case 'c': + { + const char *str = script_getstr(st, thisarg); + // Piggyback printf + StrBuf->Printf(out, buf, str[0]); + } + break; + case 'f': + case 'F': + case 'e': + case 'E': + case 'g': + case 'G': + case 'p': + case 'a': + case 'A': + ShowWarning("buildin_sprintf: Format %%%c not supported! Skipping...\n", *np); + script->reportsrc(st); + lastarg = nextarg; + p = np + 1; + continue; + default: + ShowError("buildin_sprintf: Invalid format string.\n"); + if (buf != NULL) + aFree(buf); + return false; + } + lastarg = nextarg; + p = np + 1; + } + + // Append the remaining part + if (p != NULL) + StrBuf->AppendStr(out, p); + + if (buf != NULL) + aFree(buf); + + return true; +} + //----------------------------------------------------------------------------- // buildin functions // @@ -5295,20 +5505,42 @@ const char *script_getfuncname(struct script_state *st) { BUILDIN(mes) { struct map_session_data *sd = script->rid2sd(st); - if( sd == NULL ) + if (sd == NULL) return true; - if( !script_hasdata(st, 3) ) {// only a single line detected in the script - clif->scriptmes(sd, st->oid, script_getstr(st, 2)); - } else {// parse multiple lines as they exist - int i; + clif->scriptmes(sd, st->oid, script_getstr(st, 2)); - for( i = 2; script_hasdata(st, i); i++ ) { - // send the message to the client - clif->scriptmes(sd, st->oid, script_getstr(st, i)); - } + return true; +} + +/** + * Appends a message to the npc dialog, applying format string conversions (see + * sprintf). + * + * If a dialog doesn't exist yet, one is created. + * + * @code + * mes "<message>"; + * @endcode + */ +BUILDIN(mesf) +{ + struct map_session_data *sd = script->rid2sd(st); + struct StringBuf buf; + + if (sd == NULL) + return true; + + StrBuf->Init(&buf); + + if (!script_sprintf(st, 2, &buf)) { + StrBuf->Destroy(&buf); + return false; } + clif->scriptmes(sd, st->oid, StrBuf->Value(&buf)); + StrBuf->Destroy(&buf); + return true; } @@ -8384,7 +8616,7 @@ BUILDIN(getbrokenid) num=script_getnum(st,2); for(i=0; i<MAX_INVENTORY; i++) { - if(sd->status.inventory[i].attribute) { + if ((sd->status.inventory[i].attribute & ATTR_BROKEN) != 0) { brokencounter++; if(num==brokencounter) { id=sd->status.inventory[i].nameid; @@ -8409,7 +8641,7 @@ BUILDIN(getbrokencount) return true; for (i = 0; i < MAX_INVENTORY; i++) { - if (sd->status.inventory[i].attribute) + if ((sd->status.inventory[i].attribute & ATTR_BROKEN) != 0) counter++; } @@ -8431,10 +8663,11 @@ BUILDIN(repair) num=script_getnum(st,2); for(i=0; i<MAX_INVENTORY; i++) { - if(sd->status.inventory[i].attribute) { + if ((sd->status.inventory[i].attribute & ATTR_BROKEN) != 0) { repaircounter++; if(num==repaircounter) { - sd->status.inventory[i].attribute=0; + sd->status.inventory[i].attribute |= ATTR_BROKEN; + sd->status.inventory[i].attribute ^= ATTR_BROKEN; clif->equiplist(sd); clif->produce_effect(sd, 0, sd->status.inventory[i].nameid); clif->misceffect(&sd->bl, 3); @@ -8458,9 +8691,10 @@ BUILDIN(repairall) for(i = 0; i < MAX_INVENTORY; i++) { - if(sd->status.inventory[i].nameid && sd->status.inventory[i].attribute) + if (sd->status.inventory[i].nameid && (sd->status.inventory[i].attribute & ATTR_BROKEN) != 0) { - sd->status.inventory[i].attribute = 0; + sd->status.inventory[i].attribute |= ATTR_BROKEN; + sd->status.inventory[i].attribute ^= ATTR_BROKEN; clif->produce_effect(sd,0,sd->status.inventory[i].nameid); repaircounter++; } @@ -10085,6 +10319,7 @@ int buildin_killmonsterall_sub_strip(struct block_list *bl,va_list ap) struct mob_data *md; md = BL_CAST(BL_MOB, bl); + nullpo_ret(md); if (md->npc_event[0]) md->npc_event[0] = 0; @@ -10507,7 +10742,8 @@ BUILDIN(playerattached) { /*========================================== *------------------------------------------*/ -BUILDIN(announce) { +BUILDIN(announce) +{ const char *mes = script_getstr(st,2); int flag = script_getnum(st,3); const char *fontColor = script_hasdata(st,4) ? script_getstr(st,4) : NULL; @@ -10515,6 +10751,8 @@ BUILDIN(announce) { int fontSize = script_hasdata(st,6) ? script_getnum(st,6) : 12; // default fontSize int fontAlign = script_hasdata(st,7) ? script_getnum(st,7) : 0; // default fontAlign int fontY = script_hasdata(st,8) ? script_getnum(st,8) : 0; // default fontY + size_t len = strlen(mes); + Assert_retr(false, len < INT_MAX); if( flag&(BC_TARGET_MASK|BC_SOURCE_MASK) ) { // Broadcast source or broadcast region defined @@ -10539,14 +10777,14 @@ BUILDIN(announce) { } if (fontColor) - clif->broadcast2(bl, mes, (int)strlen(mes)+1, (unsigned int)strtoul(fontColor, (char **)NULL, 0), fontType, fontSize, fontAlign, fontY, target); + clif->broadcast2(bl, mes, (int)len+1, (unsigned int)strtoul(fontColor, (char **)NULL, 0), fontType, fontSize, fontAlign, fontY, target); else - clif->broadcast(bl, mes, (int)strlen(mes)+1, flag&BC_COLOR_MASK, target); + clif->broadcast(bl, mes, (int)len+1, flag&BC_COLOR_MASK, target); } else { if (fontColor) - intif->broadcast2(mes, (int)strlen(mes)+1, (unsigned int)strtoul(fontColor, (char **)NULL, 0), fontType, fontSize, fontAlign, fontY); + intif->broadcast2(mes, (int)len+1, (unsigned int)strtoul(fontColor, (char **)NULL, 0), fontType, fontSize, fontAlign, fontY); else - intif->broadcast(mes, (int)strlen(mes)+1, flag&BC_COLOR_MASK); + intif->broadcast(mes, (int)len+1, flag&BC_COLOR_MASK); } return true; } @@ -10554,10 +10792,10 @@ BUILDIN(announce) { *------------------------------------------*/ int buildin_announce_sub(struct block_list *bl, va_list ap) { - char *mes = va_arg(ap, char *); + const char *mes = va_arg(ap, const char *); int len = va_arg(ap, int); int type = va_arg(ap, int); - char *fontColor = va_arg(ap, char *); + const char *fontColor = va_arg(ap, const char *); short fontType = (short)va_arg(ap, int); short fontSize = (short)va_arg(ap, int); short fontAlign = (short)va_arg(ap, int); @@ -10604,7 +10842,8 @@ BUILDIN(itemeffect) return true; } -BUILDIN(mapannounce) { +BUILDIN(mapannounce) +{ const char *mapname = script_getstr(st,2); const char *mes = script_getstr(st,3); int flag = script_getnum(st,4); @@ -10614,17 +10853,20 @@ BUILDIN(mapannounce) { int fontAlign = script_hasdata(st,8) ? script_getnum(st,8) : 0; // default fontAlign int fontY = script_hasdata(st,9) ? script_getnum(st,9) : 0; // default fontY int16 m; + size_t len = strlen(mes); + Assert_retr(false, len < INT_MAX); if ((m = map->mapname2mapid(mapname)) < 0) return true; map->foreachinmap(script->buildin_announce_sub, m, BL_PC, - mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); + mes, (int)len+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); return true; } /*========================================== *------------------------------------------*/ -BUILDIN(areaannounce) { +BUILDIN(areaannounce) +{ const char *mapname = script_getstr(st,2); int x0 = script_getnum(st,3); int y0 = script_getnum(st,4); @@ -10638,12 +10880,14 @@ BUILDIN(areaannounce) { int fontAlign = script_hasdata(st,12) ? script_getnum(st,12) : 0; // default fontAlign int fontY = script_hasdata(st,13) ? script_getnum(st,13) : 0; // default fontY int16 m; + size_t len = strlen(mes); + Assert_retr(false, len < INT_MAX); if ((m = map->mapname2mapid(mapname)) < 0) return true; map->foreachinarea(script->buildin_announce_sub, m, x0, y0, x1, y1, BL_PC, - mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); + mes, (int)len+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); return true; } @@ -13782,7 +14026,7 @@ BUILDIN(dispbottom) int color = script_getnum(st,3); clif->messagecolor_self(sd->fd, color, message); } else { - clif_disp_onlyself(sd, message, (int)strlen(message)); + clif_disp_onlyself(sd, message); } return true; @@ -15229,130 +15473,19 @@ BUILDIN(implode) // Implements C sprintf, except format %n. The resulting string is // returned, instead of being saved in variable by reference. //------------------------------------------------------- -BUILDIN(sprintf) { - unsigned int argc = 0, arg = 0; - const char* format; - char* p; - char* q; - char* buf = NULL; - char* buf2 = NULL; - struct script_data* data; - size_t len, buf2_len = 0; - StringBuf final_buf; - - // Fetch init data - format = script_getstr(st, 2); - argc = script_lastdata(st)-2; - len = strlen(format); - - // Skip parsing, where no parsing is required. - if(len==0) { - script_pushconststr(st,""); - return true; - } - - // Pessimistic alloc - CREATE(buf, char, len+1); - - // Need not be parsed, just solve stuff like %%. - if(argc==0) { - memcpy(buf,format,len+1); - script_pushstrcopy(st, buf); - aFree(buf); - return true; - } - - safestrncpy(buf, format, len+1); - - // Issue sprintf for each parameter - StrBuf->Init(&final_buf); - q = buf; - while((p = strchr(q, '%'))!=NULL) { - if(p!=q) { - len = p-q+1; - if(buf2_len<len) { - RECREATE(buf2, char, len); - buf2_len = len; - } - safestrncpy(buf2, q, len); - StrBuf->AppendStr(&final_buf, buf2); - q = p; - } - p = q+1; - if(*p=='%') { // %% - StrBuf->AppendStr(&final_buf, "%"); - q+=2; - continue; - } - if(*p=='n') { // %n - ShowWarning("buildin_sprintf: Format %%n not supported! Skipping...\n"); - script->reportsrc(st); - q+=2; - continue; - } - if(arg>=argc) { - ShowError("buildin_sprintf: Not enough arguments passed!\n"); - aFree(buf); - if(buf2) aFree(buf2); - StrBuf->Destroy(&final_buf); - script_pushconststr(st,""); - return false; - } - if((p = strchr(q+1, '%'))==NULL) { - p = strchr(q, 0); // EOS - } - len = p-q+1; - if(buf2_len<len) { - RECREATE(buf2, char, len); - buf2_len = len; - } - safestrncpy(buf2, q, len); - q = p; - - // Note: This assumes the passed value being the correct - // type to the current format specifier. If not, the server - // probably crashes or returns anything else, than expected, - // but it would behave in normal code the same way so it's - // the scripter's responsibility. - data = script_getdata(st, arg+3); - if(data_isstring(data)) { // String - StrBuf->Printf(&final_buf, buf2, script_getstr(st, arg+3)); - } else if(data_isint(data)) { // Number - StrBuf->Printf(&final_buf, buf2, script_getnum(st, arg+3)); - } else if(data_isreference(data)) { // Variable - char* name = reference_getname(data); - if(name[strlen(name)-1]=='$') { // var Str - StrBuf->Printf(&final_buf, buf2, script_getstr(st, arg+3)); - } else { // var Int - StrBuf->Printf(&final_buf, buf2, script_getnum(st, arg+3)); - } - } else { // Unsupported type - ShowError("buildin_sprintf: Unknown argument type!\n"); - aFree(buf); - if(buf2) aFree(buf2); - StrBuf->Destroy(&final_buf); - script_pushconststr(st,""); - return false; - } - arg++; - } - - // Append anything left - if(*q) { - StrBuf->AppendStr(&final_buf, q); - } +BUILDIN(sprintf) +{ + struct StringBuf buf; + StrBuf->Init(&buf); - // Passed more, than needed - if(arg<argc) { - ShowWarning("buildin_sprintf: Unused arguments passed.\n"); - script->reportsrc(st); + if (!script_sprintf(st, 2, &buf)) { + StrBuf->Destroy(&buf); + script_pushconststr(st, ""); + return false; } - script_pushstrcopy(st, StrBuf->Value(&final_buf)); - - aFree(buf); - if(buf2) aFree(buf2); - StrBuf->Destroy(&final_buf); + script_pushstrcopy(st, StrBuf->Value(&buf)); + StrBuf->Destroy(&buf); return true; } @@ -16479,7 +16612,7 @@ BUILDIN(checkchatting) { sd = script->rid2sd(st); if (sd != NULL) - script_pushint(st,(sd->chatID != 0)); + script_pushint(st, (sd->chat_id != 0)); else script_pushint(st,0); @@ -18017,7 +18150,8 @@ BUILDIN(instance_init) { return true; } -BUILDIN(instance_announce) { +BUILDIN(instance_announce) +{ int instance_id = script_getnum(st,2); const char *mes = script_getstr(st,3); int flag = script_getnum(st,4); @@ -18026,8 +18160,9 @@ BUILDIN(instance_announce) { int fontSize = script_hasdata(st,7) ? script_getnum(st,7) : 12; // default fontSize int fontAlign = script_hasdata(st,8) ? script_getnum(st,8) : 0; // default fontAlign int fontY = script_hasdata(st,9) ? script_getnum(st,9) : 0; // default fontY - int i; + size_t len = strlen(mes); + Assert_retr(false, len < INT_MAX); if( instance_id == -1 ) { if( st->instance_id >= 0 ) @@ -18041,7 +18176,7 @@ BUILDIN(instance_announce) { for( i = 0; i < instance->list[instance_id].num_map; i++ ) map->foreachinmap(script->buildin_announce_sub, instance->list[instance_id].map[i], BL_PC, - mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); + mes, (int)len+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY); return true; } @@ -18631,22 +18766,11 @@ BUILDIN(getcharip) { return false; } - /* check for IP */ - if (!sockt->session[sd->fd]->client_addr) { + if (sd->fd == 0 || sockt->session[sd->fd] == NULL || sockt->session[sd->fd]->client_addr == 0) { script_pushconststr(st, ""); - return true; - } - - /* return the client ip_addr converted for output */ - if (sd && sd->fd && sockt->session[sd->fd]) - { - /* initiliaze */ - const char *ip_addr = NULL; - uint32 ip; - - /* set ip, ip_addr and convert to ip and push str */ - ip = sockt->session[sd->fd]->client_addr; - ip_addr = sockt->ip2str(ip, NULL); + } else { + uint32 ip = sockt->session[sd->fd]->client_addr; + const char *ip_addr = sockt->ip2str(ip, NULL); script_pushstrcopy(st, ip_addr); } @@ -18869,68 +18993,6 @@ BUILDIN(useatcmd) { return true; } -BUILDIN(checkre) -{ - int num; - - num=script_getnum(st,2); - switch(num) { - case 0: -#ifdef RENEWAL - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 1: -#ifdef RENEWAL_CAST - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 2: -#ifdef RENEWAL_DROP - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 3: -#ifdef RENEWAL_EXP - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 4: -#ifdef RENEWAL_LVDMG - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 5: -#ifdef RENEWAL_EDP - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - case 6: -#ifdef RENEWAL_ASPD - script_pushint(st, 1); -#else - script_pushint(st, 0); -#endif - break; - default: - ShowWarning("buildin_checkre: unknown parameter.\n"); - break; - } - return true; -} - /* getrandgroupitem <container_item_id>,<quantity> */ BUILDIN(getrandgroupitem) { struct item_data *data = NULL; @@ -20272,8 +20334,10 @@ bool script_add_builtin(const struct script_function *buildin, bool override) { else if( strcmp(buildin->name, "callfunc") == 0 ) script->buildin_callfunc_ref = n; else if( strcmp(buildin->name, "getelementofarray") == 0 ) script->buildin_getelementofarray_ref = n; else if( strcmp(buildin->name, "mes") == 0 ) script->buildin_mes_offset = script->buildin_count; + else if( strcmp(buildin->name, "mesf") == 0 ) script->buildin_mesf_offset = script->buildin_count; else if( strcmp(buildin->name, "select") == 0 ) script->buildin_select_offset = script->buildin_count; else if( strcmp(buildin->name, "_") == 0 ) script->buildin_lang_macro_offset = script->buildin_count; + else if( strcmp(buildin->name, "_$") == 0 ) script->buildin_lang_macro_fmtstring_offset = script->buildin_count; offset = script->buildin_count; @@ -20367,7 +20431,8 @@ void script_parse_builtin(void) { BUILDIN_DEF(__setr,"rv?"), // NPC interaction - BUILDIN_DEF(mes,"s*"), + BUILDIN_DEF(mes,"s"), + BUILDIN_DEF(mesf,"s*"), BUILDIN_DEF(next,""), BUILDIN_DEF(close,""), BUILDIN_DEF(close2,""), @@ -20879,6 +20944,7 @@ void script_parse_builtin(void) { BUILDIN_DEF(showscript, "s?"), BUILDIN_DEF(mergeitem,""), BUILDIN_DEF(_,"s"), + BUILDIN_DEF2(_, "_$", "s"), }; int i, len = ARRAYLENGTH(BUILDIN); RECREATE(script->buildin, char *, script->buildin_count + len); // Pre-alloc to speed up @@ -21112,8 +21178,8 @@ void script_defaults(void) { script->label_count = 0; script->labels_size = 0; - script->buf = NULL; - script->pos = 0, script->size = 0; + VECTOR_INIT(script->buf); + VECTOR_INIT(script->translation_buf); script->parse_options = 0; script->buildin_set_ref = 0; @@ -21239,6 +21305,11 @@ void script_defaults(void) { script->parse_nextline = parse_nextline; script->parse_variable = parse_variable; script->parse_simpleexpr = parse_simpleexpr; + script->parse_simpleexpr_paren = parse_simpleexpr_paren; + script->parse_simpleexpr_number = parse_simpleexpr_number; + script->parse_simpleexpr_string = parse_simpleexpr_string; + script->parse_simpleexpr_name = parse_simpleexpr_name; + script->add_translatable_string = script_add_translatable_string; script->parse_expr = parse_expr; script->parse_line = parse_line; script->read_constdb = read_constdb; diff --git a/src/map/script.h b/src/map/script.h index a1fbe31f0..4df8941b7 100644 --- a/src/map/script.h +++ b/src/map/script.h @@ -394,11 +394,20 @@ struct script_data { struct reg_db *ref; ///< Reference to the scope's variables }; +/** + * A script string buffer, used to hold strings used by the script engine. + */ +VECTOR_STRUCT_DECL(script_string_buf, char); + +/** + * Script buffer, used to hold parsed script data. + */ +VECTOR_STRUCT_DECL(script_buf, unsigned char); + // Moved defsp from script_state to script_stack since // it must be saved when script state is RERUNLINE. [Eoe / jA 1094] struct script_code { - int script_size; - unsigned char *script_buf; + struct script_buf script_buf; struct reg_db local; ///< Local (npc) vars unsigned short instances; }; @@ -493,8 +502,8 @@ struct script_syntax_data { int index; // Number of the syntax used in the script int last_func; // buildin index of the last parsed function unsigned int nested_call; //Dont really know what to call this - bool lang_macro_active; - struct DBMap *strings; // string map parsed (used when exporting strings only) + bool lang_macro_active; // Used to generate translation strings + bool lang_macro_fmtstring_active; // Used to generate translation strings struct DBMap *translation_db; //non-null if this npc has any translated strings to be linked }; @@ -517,16 +526,16 @@ struct script_array { unsigned int *members;/* member list */ }; -struct script_string_buf { - char *ptr; - size_t pos,size; +struct string_translation_entry { + uint8 lang_id; + char string[]; }; struct string_translation { int string_id; uint8 translations; - unsigned int len; - char *buf; + int len; + uint8 *buf; // Array of struct string_translation_entry }; /** @@ -576,8 +585,7 @@ struct script_interface { /* */ /// temporary buffer for passing around compiled bytecode /// @see add_scriptb, set_label, parse_script - unsigned char* buf; - int pos, size; + struct script_buf buf; /* */ struct script_syntax_data syntax; /* */ @@ -611,26 +619,22 @@ struct script_interface { /* */ unsigned int *generic_ui_array; unsigned int generic_ui_array_size; - /* Set during startup when attempting to export the lang, unset after server initialization is over */ - FILE *lang_export_fp; - char *lang_export_file;/* for lang_export_fp */ /* set and unset on npc_parse_script */ const char *parser_current_npc_name; /* */ int buildin_mes_offset; + int buildin_mesf_offset; int buildin_select_offset; int buildin_lang_macro_offset; + int buildin_lang_macro_fmtstring_offset; /* */ struct DBMap *translation_db;/* npc_name => DBMap (strings) */ - char **translation_buf;/* */ - uint32 translation_buf_size; + VECTOR_DECL(uint8 *) translation_buf; /* */ char **languages; uint8 max_lang_id; /* */ - struct script_string_buf parse_simpleexpr_str; - struct script_string_buf lang_export_line_buf; - struct script_string_buf lang_export_unescaped_buf; + struct script_string_buf parse_simpleexpr_strbuf; /* */ int parse_cleanup_timer_id; /* */ @@ -706,8 +710,8 @@ struct script_interface { const char * (*parse_syntax_close) (const char *p); const char * (*parse_syntax_close_sub) (const char *p, int *flag); const char * (*parse_syntax) (const char *p); - c_op (*get_com) (unsigned char *scriptbuf, int *pos); - int (*get_num) (unsigned char *scriptbuf, int *pos); + c_op (*get_com) (const struct script_buf *scriptbuf, int *pos); + int (*get_num) (const struct script_buf *scriptbuf, int *pos); const char* (*op2name) (int op); void (*reportsrc) (struct script_state *st); void (*reportdata) (struct script_data *data); @@ -724,10 +728,15 @@ struct script_interface { int (*add_word) (const char *p); const char* (*parse_callfunc) (const char *p, int require_paren, int is_custom); void (*parse_nextline) (bool first, const char *p); - const char* (*parse_variable) (const char *p); - const char* (*parse_simpleexpr) (const char *p); - const char* (*parse_expr) (const char *p); - const char* (*parse_line) (const char *p); + const char *(*parse_variable) (const char *p); + const char *(*parse_simpleexpr) (const char *p); + const char *(*parse_simpleexpr_paren) (const char *p); + const char *(*parse_simpleexpr_number) (const char *p); + const char *(*parse_simpleexpr_string) (const char *p); + const char *(*parse_simpleexpr_name) (const char *p); + void (*add_translatable_string) (const struct script_string_buf *string, const char *start_point); + const char *(*parse_expr) (const char *p); + const char *(*parse_line) (const char *p); void (*read_constdb) (void); void (*constdb_comment) (const char *comment); void (*load_parameters) (void); @@ -749,7 +758,7 @@ struct script_interface { void (*op_2num) (struct script_state *st, int op, int i1, int i2); void (*op_2) (struct script_state *st, int op); void (*op_1) (struct script_state *st, int op); - void (*check_buildin_argtype) (struct script_state *st, int func); + bool (*check_buildin_argtype) (struct script_state *st, int func); void (*detach_state) (struct script_state *st, bool dequeue_event); int (*db_free_code_sub) (union DBKey key, struct DBData *data, va_list ap); void (*add_autobonus) (const char *autobonus); @@ -807,7 +816,7 @@ struct script_interface { unsigned short (*mapindexname2id) (struct script_state *st, const char* name); int (*string_dup) (char *str); void (*load_translations) (void); - void (*load_translation) (const char *file, uint8 lang_id, uint32 *total); + int (*load_translation) (const char *file, uint8 lang_id); int (*translation_db_destroyer) (union DBKey key, struct DBData *data, va_list ap); void (*clear_translations) (bool reload); int (*parse_cleanup_timer) (int tid, int64 tick, int id, intptr_t data); diff --git a/src/map/skill.c b/src/map/skill.c index fb0d54e23..dceebb5b2 100644 --- a/src/map/skill.c +++ b/src/map/skill.c @@ -84,7 +84,8 @@ struct s_skill_dbs skilldbs; struct skill_interface *skill; //Since only mob-casted splash skills can hit ice-walls -static inline int splash_target(struct block_list* bl) { +int skill_splash_target(struct block_list* bl) +{ #ifndef RENEWAL return ( bl->type == BL_MOB ) ? BL_SKILL|BL_CHAR : BL_CHAR; #else // Some skills can now hit ground skills(traps, ice wall & etc.) @@ -2006,7 +2007,7 @@ int skill_break_equip (struct block_list *bl, unsigned short where, int rate, in if (sd) { for (i = 0; i < EQI_MAX; i++) { int j = sd->equip_index[i]; - if (j < 0 || sd->status.inventory[j].attribute == 1 || !sd->inventory_data[j]) + if (j < 0 || (sd->status.inventory[j].attribute & ATTR_BROKEN) != 0 || !sd->inventory_data[j]) continue; switch(i) { @@ -2032,7 +2033,7 @@ int skill_break_equip (struct block_list *bl, unsigned short where, int rate, in continue; } if (flag) { - sd->status.inventory[j].attribute = 1; + sd->status.inventory[j].attribute |= ATTR_BROKEN; pc->unequipitem(sd, j, PCUNEQUIPITEM_RECALC|PCUNEQUIPITEM_FORCE); } } @@ -2069,12 +2070,12 @@ int skill_strip_equip(struct block_list *bl, unsigned short where, int rate, int return where?1:0; } /*========================================================================= - Used to knock back players, monsters, traps, etc - - 'count' is the number of squares to knock back - - 'direction' indicates the way OPPOSITE to the knockback direction (or -1 for default behavior) - - if 'flag&0x1', position update packets must not be sent. - - if 'flag&0x2', skill blown ignores players' special_state.no_knockback - -------------------------------------------------------------------------*/ + * Used to knock back players, monsters, traps, etc + * 'count' is the number of squares to knock back + * 'direction' indicates the way OPPOSITE to the knockback direction (or -1 for default behavior) + * if 'flag&0x1', position update packets must not be sent. + * if 'flag&0x2', skill blown ignores players' special_state.no_knockback + */ int skill_blown(struct block_list* src, struct block_list* target, int count, int8 dir, int flag) { int dx = 0, dy = 0; @@ -2891,11 +2892,11 @@ void skill_attack_display_unknown(int *attack_type, struct block_list* src, stru } int skill_attack_copy_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { - return *skill_id; + return *skill_id; } int skill_attack_dir_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { - return -1; + return -1; } void skill_attack_blow_unknown(int *attack_type, struct block_list* src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir) { @@ -3745,7 +3746,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 if (!(flag&1) && sc && sc->data[SC_SOULLINK] && sc->data[SC_SOULLINK]->val2 == SL_MONK) { //Becomes a splash attack when Soul Linked. map->foreachinrange(skill->area_sub, bl, - skill->get_splash(skill_id, skill_lv),splash_target(src), + skill->get_splash(skill_id, skill_lv),skill->splash_target(src), src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1, skill->castend_damage_id); } else @@ -3756,7 +3757,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 clif->skill_nodamage(src,bl,skill_id,skill_lv,1); skill->area_temp[1] = 0; map->foreachinrange(skill->attack_area, src, - skill->get_splash(skill_id, skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv), skill->splash_target(src), BF_WEAPON, src, src, skill_id, skill_lv, tick, flag, BCT_ENEMY); break; @@ -3792,7 +3793,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 //line of sight between caster and target. skill->area_temp[1] = bl->id; map->foreachinpath(skill->attack_area,src->m,src->x,src->y,bl->x,bl->y, - skill->get_splash(skill_id, skill_lv),skill->get_maxcount(skill_id,skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv),skill->get_maxcount(skill_id,skill_lv), skill->splash_target(src), skill->get_type(skill_id),src,src,skill_id,skill_lv,tick,flag,BCT_ENEMY); break; @@ -3803,7 +3804,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 case NPC_THUNDERBREATH: skill->area_temp[1] = bl->id; map->foreachinpath(skill->attack_area,src->m,src->x,src->y,bl->x,bl->y, - skill->get_splash(skill_id, skill_lv),skill->get_maxcount(skill_id,skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv),skill->get_maxcount(skill_id,skill_lv), skill->splash_target(src), skill->get_type(skill_id),src,src,skill_id,skill_lv,tick,flag,BCT_ENEMY); break; @@ -4006,7 +4007,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 skill->area_temp[0] = map->foreachinrange(skill->area_sub, bl, (skill_id == AS_SPLASHER)?1:skill->get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill->area_sub_count); // recursive invocation of skill->castend_damage_id() with flag|1 - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); } break; @@ -4087,9 +4088,9 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 // Splash around target cell, but only cells inside area; we first have to check the area is not negative if((max(min_x,tx-1) <= min(max_x,tx+1)) && (max(min_y,ty-1) <= min(max_y,ty+1)) && - (map->foreachinarea(skill->area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY, skill->area_sub_count))) { + (map->foreachinarea(skill->area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY, skill->area_sub_count))) { // Recursive call - map->foreachinarea(skill->area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, (flag|BCT_ENEMY)+1, skill->castend_damage_id); + map->foreachinarea(skill->area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), skill->splash_target(src), src, skill_id, skill_lv, tick, (flag|BCT_ENEMY)+1, skill->castend_damage_id); // Self-collision if(bl->x >= min_x && bl->x <= max_x && bl->y >= min_y && bl->y <= max_y) skill->attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,(flag&0xFFF)>0?SD_ANIMATION:0); @@ -4590,7 +4591,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 status_change_end(bl, SC_CLOAKING, INVALID_TIMER); status_change_end(bl, SC_CLOAKINGEXCEED, INVALID_TIMER); // Need confirm it. } else { - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); clif->skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, BDT_SKILL); if( sd ) pc->overheat(sd,1); } @@ -4608,7 +4609,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 // Destination area skill->area_temp[4] = x; skill->area_temp[5] = y; - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill->castend_damage_id); skill->addtimerskill(src,tick + 800,src->id,x,y,skill_id,skill_lv,0,flag); // To teleport Self clif->skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,BDT_SKILL); } @@ -4667,7 +4668,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 status_change_end(bl, SC_HIDING, INVALID_TIMER); status_change_end(bl, SC_CLOAKINGEXCEED, INVALID_TIMER); } else{ - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); clif->skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, BDT_SKILL); } break; @@ -4804,7 +4805,7 @@ int skill_castend_damage_id(struct block_list* src, struct block_list *bl, uint1 if(flag & 1) skill->attack(skill->get_type(skill_id), src, src, bl, skill_id, skill_lv, tick, flag); else { - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag | BCT_ENEMY | SD_SPLASH | 1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag | BCT_ENEMY | SD_SPLASH | 1, skill->castend_damage_id); } break; @@ -5220,7 +5221,7 @@ int skill_castend_id(int tid, int64 tick, int id, intptr_t data) { bool skill_castend_id_unknown(struct unit_data *ud, struct block_list *src, struct block_list *target) { - return false; + return false; } /*========================================== @@ -5456,7 +5457,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin heal_get_jobexp = heal_get_jobexp * battle_config.heal_exp / 100; if (heal_get_jobexp <= 0) heal_get_jobexp = 1; - pc->gainexp (sd, bl, 0, heal_get_jobexp, false); + pc->gainexp(sd, bl, 0, heal_get_jobexp, false); } } break; @@ -5532,7 +5533,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin if (jexp < 1) jexp = 1; } if(exp > 0 || jexp > 0) - pc->gainexp (sd, bl, exp, jexp, false); + pc->gainexp(sd, bl, exp, jexp, false); } } } @@ -6260,7 +6261,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin skill->area_temp[1] = 0; clif->skill_nodamage(src,bl,skill_id,skill_lv,1); map->foreachinrange(skill->area_sub, bl, - skill->get_splash(skill_id, skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1, skill->castend_damage_id); status_change_end(src, SC_HIDING, INVALID_TIMER); @@ -6279,7 +6280,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin int count = 0; skill->area_temp[1] = 0; clif->skill_nodamage(src,bl,skill_id,skill_lv,1); - count = map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), + count = map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_damage_id); if( !count && ( skill_id == NC_AXETORNADO || skill_id == SR_SKYNETBLOW || skill_id == KO_HAPPOKUNAI ) ) clif->skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, BDT_SKILL); @@ -6325,7 +6326,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin clif->skill_nodamage(src,bl,skill_id,skill_lv,1); skill->area_temp[1] = 0; map->foreachinrange(skill->attack_area, src, - skill->get_splash(skill_id, skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv), skill->splash_target(src), BF_MAGIC, src, src, skill_id, skill_lv, tick, flag, BCT_ENEMY); break; @@ -6339,7 +6340,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin clif->skill_nodamage(src, src, skill_id, -1, 1); map->delblock(src); //Required to prevent chain-self-destructions hitting back. map->foreachinrange(skill->area_sub, bl, - skill->get_splash(skill_id, skill_lv), splash_target(src), + skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|targetmask, skill->castend_damage_id); map->addblock(src); @@ -8736,7 +8737,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin int failure; if( (failure = sc_start2(src,bl,type,100,skill_lv,src->id,skill->get_time(skill_id,skill_lv))) ) { - map->foreachinrange(skill->area_sub,src,skill->get_splash(skill_id,skill_lv),splash_target(src),src,skill_id,skill_lv,tick,flag|BCT_ENEMY|SD_SPLASH|1,skill->castend_damage_id);; + map->foreachinrange(skill->area_sub,src,skill->get_splash(skill_id,skill_lv),skill->splash_target(src),src,skill_id,skill_lv,tick,flag|BCT_ENEMY|SD_SPLASH|1,skill->castend_damage_id);; clif->skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,BDT_SKILL); if (sd) pc->overheat(sd,1); } @@ -9077,7 +9078,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin clif->skill_nodamage(src, bl, skill_id, skill_lv, sp ? 1:0); } else { clif->skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, BDT_SKILL); - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF|SD_SPLASH|1, skill->castend_nodamage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF|SD_SPLASH|1, skill->castend_nodamage_id); } break; @@ -9281,7 +9282,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin improv_skill_lv = 4 + skill_lv; clif->skill_nodamage (src, bl, skill_id, skill_lv, 1); - if (sd == NULL) { + if (sd != NULL) { sd->state.abra_flag = 2; sd->skillitem = improv_skill_id; sd->skillitemlv = improv_skill_lv; @@ -9769,7 +9770,7 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin } } else { skill->area_temp[2] = 0; - map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_nodamage_id); + map->foreachinrange(skill->area_sub, bl, skill->get_splash(skill_id, skill_lv), skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill->castend_nodamage_id); } break; @@ -9900,17 +9901,17 @@ int skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uin bool skill_castend_nodamage_id_dead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { - return true; + return true; } bool skill_castend_nodamage_id_undead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { - return true; + return true; } bool skill_castend_nodamage_id_mado_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { - return false; + return false; } bool skill_castend_nodamage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) @@ -10084,7 +10085,7 @@ int skill_castend_pos(int tid, int64 tick, int id, intptr_t data) } -static int check_npc_chaospanic(struct block_list *bl, va_list args) +int skill_check_npc_chaospanic(struct block_list *bl, va_list args) { const struct npc_data *nd = NULL; @@ -10098,7 +10099,8 @@ static int check_npc_chaospanic(struct block_list *bl, va_list args) return 1; } /* skill count without self */ -static int skill_count_wos(struct block_list *bl,va_list ap) { +int skill_count_wos(struct block_list *bl, va_list ap) +{ struct block_list* src = va_arg(ap, struct block_list*); if( src->id != bl->id ) { return 1; @@ -10340,7 +10342,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui case SC_CHAOSPANIC: case SC_MAELSTROM: - if (sd && map->foreachinarea(&check_npc_chaospanic,src->m, x-3, y-3, x+3, y+3, BL_NPC) > 0 ) { + if (sd && map->foreachinarea(skill->check_npc_chaospanic, src->m, x-3, y-3, x+3, y+3, BL_NPC) > 0 ) { clif->skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0); break; } @@ -10482,7 +10484,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui if( sc && sc->data[SC_BASILICA] ) status_change_end(src, SC_BASILICA, INVALID_TIMER); // Cancel Basilica else { // Create Basilica. Start SC on caster. Unit timer start SC on others. - if( map->foreachinrange(skill_count_wos, src, 2, BL_MOB|BL_PC, src) ) { + if( map->foreachinrange(skill->count_wos, src, 2, BL_MOB|BL_PC, src) ) { if( sd ) clif->skill_fail(sd,skill_id,USESKILL_FAIL,0); return 1; @@ -10747,7 +10749,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui case RK_DRAGONBREATH: case RK_DRAGONBREATH_WATER: r = skill->get_splash(skill_id,skill_lv); - map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,splash_target(src), + map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,skill->splash_target(src), src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill->castend_damage_id); break; case WM_GREAT_ECHO: @@ -10769,7 +10771,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui break; case SO_ARRULLO: r = skill->get_splash(skill_id,skill_lv); - map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,splash_target(src), + map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,skill->splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill->castend_nodamage_id); break; /** @@ -10884,7 +10886,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui case LG_RAYOFGENESIS: if( status->charge(src,status_get_max_hp(src)*3*skill_lv / 100,0) ) { r = skill->get_splash(skill_id,skill_lv); - map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,splash_target(src), + map->foreachinarea(skill->area_sub,src->m,x-r,y-r,x+r,y+r,skill->splash_target(src), src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill->castend_damage_id); } else if( sd ) clif->skill_fail(sd,skill_id,USESKILL_FAIL,0); @@ -11717,7 +11719,7 @@ int skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 tick if (bl->type == BL_PC && !working) { struct map_session_data *sd = BL_UCAST(BL_PC, bl); - if ((!sd->chatID || battle_config.chat_warpportal) && sd->ud.to_x == src->bl.x && sd->ud.to_y == src->bl.y) { + if ((sd->chat_id == 0 || battle_config.chat_warpportal) && sd->ud.to_x == src->bl.x && sd->ud.to_y == src->bl.y) { int x = sg->val2>>16; int y = sg->val2&0xffff; int count = sg->val1>>16; @@ -13123,7 +13125,8 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id nullpo_ret(sd); - if (sd->chatID) return 0; + if (sd->chat_id != 0) + return 0; if (pc_has_permission(sd, PC_PERM_SKILL_UNCONDITIONAL) && sd->skillitem != skill_id) { //GMs don't override the skillItem check, otherwise they can use items without them being consumed! [Skotlex] @@ -14063,22 +14066,22 @@ int skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_id int skill_check_condition_castbegin_off_unknown(struct status_change *sc, uint16 *skill_id) { - return -1; + return -1; } int skill_check_condition_castbegin_mount_unknown(struct status_change *sc, uint16 *skill_id) { - return 0; + return 0; } int skill_check_condition_castbegin_madogear_unknown(struct status_change *sc, uint16 *skill_id) { - return 0; + return 0; } int skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 *skill_id) { - return -1; + return -1; } int skill_check_condition_castend(struct map_session_data* sd, uint16 skill_id, uint16 skill_lv) { @@ -14089,7 +14092,7 @@ int skill_check_condition_castend(struct map_session_data* sd, uint16 skill_id, nullpo_ret(sd); - if( sd->chatID ) + if (sd->chat_id != 0) return 0; if( pc_has_permission(sd, PC_PERM_SKILL_UNCONDITIONAL) && sd->skillitem != skill_id ) { @@ -14701,12 +14704,12 @@ struct skill_condition skill_get_requirement(struct map_session_data* sd, uint16 bool skill_get_requirement_off_unknown(struct status_change *sc, uint16 *skill_id) { - return false; + return false; } bool skill_get_requirement_item_unknown(struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i) { - return false; + return false; } void skill_get_requirement_unknown(struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req) @@ -15222,7 +15225,7 @@ void skill_repairweapon (struct map_session_data *sd, int idx) { return; //Invalid index?? item = &target_sd->status.inventory[idx]; - if( item->nameid <= 0 || item->attribute == 0 ) + if( item->nameid <= 0 || (item->attribute & ATTR_BROKEN) == 0 ) return; //Again invalid item.... if( sd != target_sd && !battle->check_range(&sd->bl,&target_sd->bl, skill->get_range2(&sd->bl, sd->menuskill_id,sd->menuskill_val2) ) ){ @@ -15241,7 +15244,8 @@ void skill_repairweapon (struct map_session_data *sd, int idx) { clif->skill_nodamage(&sd->bl,&target_sd->bl,sd->menuskill_id,1,1); - item->attribute = 0;/* clear broken state */ + item->attribute |= ATTR_BROKEN; + item->attribute ^= ATTR_BROKEN; /* clear broken state */ clif->equiplist(target_sd); @@ -15995,14 +15999,14 @@ int skill_enchant_elemental_end (struct block_list *bl, int type) { bool skill_check_cloaking(struct block_list *bl, struct status_change_entry *sce) { - static int dx[] = { 0, 1, 0, -1, -1, 1, 1, -1}; - static int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1}; bool wall = true; if( (bl->type == BL_PC && battle_config.pc_cloak_check_type&1) || (bl->type != BL_PC && battle_config.monster_cloak_check_type&1) ) { //Check for walls. + static int dx[] = { 0, 1, 0, -1, -1, 1, 1, -1}; + static int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1}; int i; ARR_FIND( 0, 8, i, map->getcell(bl->m, bl, bl->x+dx[i], bl->y+dy[i], CELL_CHKNOPASS) != 0 ); if( i == 8 ) @@ -16060,11 +16064,11 @@ int skill_check_cloaking_end(struct block_list *bl, va_list ap) bool skill_check_camouflage(struct block_list *bl, struct status_change_entry *sce) { - static int dx[] = { 0, 1, 0, -1, -1, 1, 1, -1}; - static int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1}; bool wall = true; if( bl->type == BL_PC ) { //Check for walls. + static int dx[] = { 0, 1, 0, -1, -1, 1, 1, -1}; + static int dy[] = {-1, 0, 1, 0, -1, -1, 1, 1}; int i; ARR_FIND( 0, 8, i, map->getcell(bl->m, bl, bl->x+dx[i], bl->y+dy[i], CELL_CHKNOPASS) != 0 ); if( i == 8 ) @@ -16671,7 +16675,7 @@ int skill_unit_timer_sub(union DBKey key, struct DBData *data, va_list ap) case UNT_FEINTBOMB: { struct block_list *src = map->id2bl(group->src_id); if( src ) { - map->foreachinrange(skill->area_sub, &su->bl, su->range, splash_target(src), src, SC_FEINTBOMB, group->skill_lv, tick, BCT_ENEMY|SD_ANIMATION|1, skill->castend_damage_id); + map->foreachinrange(skill->area_sub, &su->bl, su->range, skill->splash_target(src), src, SC_FEINTBOMB, group->skill_lv, tick, BCT_ENEMY|SD_ANIMATION|1, skill->castend_damage_id); status_change_end(src, SC__FEINTBOMB_MASTER, INVALID_TIMER); } skill->delunit(su); @@ -20634,4 +20638,7 @@ void skill_defaults(void) { skill->get_requirement_off_unknown = skill_get_requirement_off_unknown; skill->get_requirement_item_unknown = skill_get_requirement_item_unknown; skill->get_requirement_unknown = skill_get_requirement_unknown; + skill->splash_target = skill_splash_target; + skill->check_npc_chaospanic = skill_check_npc_chaospanic; + skill->count_wos = skill_count_wos; } diff --git a/src/map/skill.h b/src/map/skill.h index 9bb3eae13..45f025e74 100644 --- a/src/map/skill.h +++ b/src/map/skill.h @@ -2113,6 +2113,9 @@ struct skill_interface { bool (*get_requirement_off_unknown) (struct status_change *sc, uint16 *skill_id); bool (*get_requirement_item_unknown) (struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i); void (*get_requirement_unknown) (struct status_change *sc, struct map_session_data* sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req); + int (*splash_target) (struct block_list* bl); + int (*check_npc_chaospanic) (struct block_list *bl, va_list args); + int (*count_wos) (struct block_list *bl, va_list ap); }; #ifdef HERCULES_CORE diff --git a/src/map/status.c b/src/map/status.c index a8771c0a5..83d8943c9 100644 --- a/src/map/status.c +++ b/src/map/status.c @@ -125,7 +125,8 @@ int status_type2relevant_bl_types(int type) return status->dbs->RelevantBLTypes[type]; } -static void set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) { +void status_set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) +{ uint16 idx; if( (idx = skill->get_index(skill_id)) == 0 ) { ShowError("set_sc: Unsupported skill id %d\n", skill_id); @@ -147,9 +148,9 @@ static void set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) { } void initChangeTables(void) { -#define add_sc(skill,sc) set_sc((skill),(sc),SI_BLANK,SCB_NONE) +#define add_sc(skill,sc) status->set_sc((skill),(sc),SI_BLANK,SCB_NONE) // indicates that the status displays a visual effect for the affected unit, and should be sent to the client for all supported units -#define set_sc_with_vfx(skill, sc, icon, flag) do { set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) status->dbs->RelevantBLTypes[(icon)] |= BL_SCEFFECT; } while(0) +#define set_sc_with_vfx(skill, sc, icon, flag) do { status->set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) status->dbs->RelevantBLTypes[(icon)] |= BL_SCEFFECT; } while(0) int i; @@ -167,83 +168,83 @@ void initChangeTables(void) { memset(status->dbs->DisplayType, 0, sizeof(status->dbs->DisplayType)); //First we define the skill for common ailments. These are used in skill_additional_effect through sc cards. [Skotlex] - set_sc( NPC_PETRIFYATTACK , SC_STONE , SI_BLANK , SCB_DEF_ELE|SCB_DEF|SCB_MDEF ); - set_sc( NPC_WIDEFREEZE , SC_FREEZE , SI_BLANK , SCB_DEF_ELE|SCB_DEF|SCB_MDEF ); - set_sc( NPC_STUNATTACK , SC_STUN , SI_BLANK , SCB_NONE ); - set_sc( NPC_SLEEPATTACK , SC_SLEEP , SI_BLANK , SCB_NONE ); - set_sc( NPC_POISON , SC_POISON , SI_BLANK , SCB_DEF2|SCB_REGEN ); - set_sc( NPC_CURSEATTACK , SC_CURSE , SI_BLANK , SCB_LUK|SCB_BATK|SCB_WATK|SCB_SPEED ); - set_sc( NPC_SILENCEATTACK , SC_SILENCE , SI_BLANK , SCB_NONE ); - set_sc( NPC_WIDECONFUSE , SC_CONFUSION , SI_BLANK , SCB_NONE ); - set_sc( NPC_BLINDATTACK , SC_BLIND , SI_BLANK , SCB_HIT|SCB_FLEE ); - set_sc( NPC_BLEEDING , SC_BLOODING , SI_BLOODING , SCB_REGEN ); - set_sc( NPC_POISON , SC_DPOISON , SI_BLANK , SCB_DEF2|SCB_REGEN ); + status->set_sc( NPC_PETRIFYATTACK , SC_STONE , SI_BLANK , SCB_DEF_ELE|SCB_DEF|SCB_MDEF ); + status->set_sc( NPC_WIDEFREEZE , SC_FREEZE , SI_BLANK , SCB_DEF_ELE|SCB_DEF|SCB_MDEF ); + status->set_sc( NPC_STUNATTACK , SC_STUN , SI_BLANK , SCB_NONE ); + status->set_sc( NPC_SLEEPATTACK , SC_SLEEP , SI_BLANK , SCB_NONE ); + status->set_sc( NPC_POISON , SC_POISON , SI_BLANK , SCB_DEF2|SCB_REGEN ); + status->set_sc( NPC_CURSEATTACK , SC_CURSE , SI_BLANK , SCB_LUK|SCB_BATK|SCB_WATK|SCB_SPEED ); + status->set_sc( NPC_SILENCEATTACK , SC_SILENCE , SI_BLANK , SCB_NONE ); + status->set_sc( NPC_WIDECONFUSE , SC_CONFUSION , SI_BLANK , SCB_NONE ); + status->set_sc( NPC_BLINDATTACK , SC_BLIND , SI_BLANK , SCB_HIT|SCB_FLEE ); + status->set_sc( NPC_BLEEDING , SC_BLOODING , SI_BLOODING , SCB_REGEN ); + status->set_sc( NPC_POISON , SC_DPOISON , SI_BLANK , SCB_DEF2|SCB_REGEN ); //The main status definitions add_sc( SM_BASH , SC_STUN ); - set_sc( SM_PROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); + status->set_sc( SM_PROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); add_sc( SM_MAGNUM , SC_SUB_WEAPONPROPERTY ); - set_sc( SM_ENDURE , SC_ENDURE , SI_ENDURE , SCB_MDEF|SCB_DSPD ); + status->set_sc( SM_ENDURE , SC_ENDURE , SI_ENDURE , SCB_MDEF|SCB_DSPD ); add_sc( MG_SIGHT , SC_SIGHT ); add_sc( MG_SAFETYWALL , SC_SAFETYWALL ); add_sc( MG_FROSTDIVER , SC_FREEZE ); add_sc( MG_STONECURSE , SC_STONE ); add_sc( AL_RUWACH , SC_RUWACH ); add_sc( AL_PNEUMA , SC_PNEUMA ); - set_sc( AL_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); - set_sc( AL_DECAGI , SC_DEC_AGI , SI_DEC_AGI , SCB_AGI|SCB_SPEED ); - set_sc( AL_CRUCIS , SC_CRUCIS , SI_CRUCIS , SCB_DEF ); - set_sc( AL_ANGELUS , SC_ANGELUS , SI_ANGELUS , SCB_DEF2 ); - set_sc( AL_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); - set_sc( AC_CONCENTRATION , SC_CONCENTRATION , SI_CONCENTRATION , SCB_AGI|SCB_DEX ); - set_sc( TF_HIDING , SC_HIDING , SI_HIDING , SCB_SPEED ); + status->set_sc( AL_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); + status->set_sc( AL_DECAGI , SC_DEC_AGI , SI_DEC_AGI , SCB_AGI|SCB_SPEED ); + status->set_sc( AL_CRUCIS , SC_CRUCIS , SI_CRUCIS , SCB_DEF ); + status->set_sc( AL_ANGELUS , SC_ANGELUS , SI_ANGELUS , SCB_DEF2 ); + status->set_sc( AL_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); + status->set_sc( AC_CONCENTRATION , SC_CONCENTRATION , SI_CONCENTRATION , SCB_AGI|SCB_DEX ); + status->set_sc( TF_HIDING , SC_HIDING , SI_HIDING , SCB_SPEED ); add_sc( TF_POISON , SC_POISON ); - set_sc( KN_TWOHANDQUICKEN , SC_TWOHANDQUICKEN , SI_TWOHANDQUICKEN , SCB_ASPD ); + status->set_sc( KN_TWOHANDQUICKEN , SC_TWOHANDQUICKEN , SI_TWOHANDQUICKEN , SCB_ASPD ); add_sc( KN_AUTOCOUNTER , SC_AUTOCOUNTER ); - set_sc( PR_IMPOSITIO , SC_IMPOSITIO , SI_IMPOSITIO , + status->set_sc( PR_IMPOSITIO , SC_IMPOSITIO , SI_IMPOSITIO , #ifdef RENEWAL SCB_NONE ); #else SCB_WATK ); #endif - set_sc( PR_SUFFRAGIUM , SC_SUFFRAGIUM , SI_SUFFRAGIUM , SCB_NONE ); - set_sc( PR_ASPERSIO , SC_ASPERSIO , SI_ASPERSIO , SCB_ATK_ELE ); - set_sc( PR_BENEDICTIO , SC_BENEDICTIO , SI_BENEDICTIO , SCB_DEF_ELE ); - set_sc( PR_SLOWPOISON , SC_SLOWPOISON , SI_SLOWPOISON , SCB_REGEN ); - set_sc( PR_KYRIE , SC_KYRIE , SI_KYRIE , SCB_NONE ); - set_sc( PR_MAGNIFICAT , SC_MAGNIFICAT , SI_MAGNIFICAT , SCB_REGEN ); - set_sc( PR_GLORIA , SC_GLORIA , SI_GLORIA , SCB_LUK ); + status->set_sc( PR_SUFFRAGIUM , SC_SUFFRAGIUM , SI_SUFFRAGIUM , SCB_NONE ); + status->set_sc( PR_ASPERSIO , SC_ASPERSIO , SI_ASPERSIO , SCB_ATK_ELE ); + status->set_sc( PR_BENEDICTIO , SC_BENEDICTIO , SI_BENEDICTIO , SCB_DEF_ELE ); + status->set_sc( PR_SLOWPOISON , SC_SLOWPOISON , SI_SLOWPOISON , SCB_REGEN ); + status->set_sc( PR_KYRIE , SC_KYRIE , SI_KYRIE , SCB_NONE ); + status->set_sc( PR_MAGNIFICAT , SC_MAGNIFICAT , SI_MAGNIFICAT , SCB_REGEN ); + status->set_sc( PR_GLORIA , SC_GLORIA , SI_GLORIA , SCB_LUK ); add_sc( PR_LEXDIVINA , SC_SILENCE ); - set_sc( PR_LEXAETERNA , SC_LEXAETERNA , SI_LEXAETERNA , SCB_NONE ); + status->set_sc( PR_LEXAETERNA , SC_LEXAETERNA , SI_LEXAETERNA , SCB_NONE ); add_sc( WZ_METEOR , SC_STUN ); add_sc( WZ_VERMILION , SC_BLIND ); add_sc( WZ_FROSTNOVA , SC_FREEZE ); add_sc( WZ_STORMGUST , SC_FREEZE ); - set_sc( WZ_QUAGMIRE , SC_QUAGMIRE , SI_QUAGMIRE , SCB_AGI|SCB_DEX|SCB_ASPD|SCB_SPEED ); - set_sc( BS_ADRENALINE , SC_ADRENALINE , SI_ADRENALINE , SCB_ASPD ); - set_sc( BS_WEAPONPERFECT , SC_WEAPONPERFECT , SI_WEAPONPERFECT, SCB_NONE ); - set_sc( BS_OVERTHRUST , SC_OVERTHRUST , SI_OVERTHRUST , SCB_NONE ); - set_sc( BS_MAXIMIZE , SC_MAXIMIZEPOWER , SI_MAXIMIZE , SCB_REGEN ); + status->set_sc( WZ_QUAGMIRE , SC_QUAGMIRE , SI_QUAGMIRE , SCB_AGI|SCB_DEX|SCB_ASPD|SCB_SPEED ); + status->set_sc( BS_ADRENALINE , SC_ADRENALINE , SI_ADRENALINE , SCB_ASPD ); + status->set_sc( BS_WEAPONPERFECT , SC_WEAPONPERFECT , SI_WEAPONPERFECT, SCB_NONE ); + status->set_sc( BS_OVERTHRUST , SC_OVERTHRUST , SI_OVERTHRUST , SCB_NONE ); + status->set_sc( BS_MAXIMIZE , SC_MAXIMIZEPOWER , SI_MAXIMIZE , SCB_REGEN ); add_sc( HT_LANDMINE , SC_STUN ); - set_sc( HT_ANKLESNARE , SC_ANKLESNARE , SI_ANKLESNARE , SCB_NONE ); + status->set_sc( HT_ANKLESNARE , SC_ANKLESNARE , SI_ANKLESNARE , SCB_NONE ); add_sc( HT_SANDMAN , SC_SLEEP ); add_sc( HT_FLASHER , SC_BLIND ); add_sc( HT_FREEZINGTRAP , SC_FREEZE ); - set_sc( AS_CLOAKING , SC_CLOAKING , SI_CLOAKING , SCB_CRI|SCB_SPEED ); + status->set_sc( AS_CLOAKING , SC_CLOAKING , SI_CLOAKING , SCB_CRI|SCB_SPEED ); add_sc( AS_SONICBLOW , SC_STUN ); - set_sc( AS_ENCHANTPOISON , SC_ENCHANTPOISON , SI_ENCHANTPOISON, SCB_ATK_ELE ); - set_sc( AS_POISONREACT , SC_POISONREACT , SI_POISONREACT , SCB_NONE ); + status->set_sc( AS_ENCHANTPOISON , SC_ENCHANTPOISON , SI_ENCHANTPOISON, SCB_ATK_ELE ); + status->set_sc( AS_POISONREACT , SC_POISONREACT , SI_POISONREACT , SCB_NONE ); add_sc( AS_VENOMDUST , SC_POISON ); add_sc( AS_SPLASHER , SC_SPLASHER ); - set_sc( NV_TRICKDEAD , SC_TRICKDEAD , SI_TRICKDEAD , SCB_REGEN ); - set_sc( SM_AUTOBERSERK , SC_AUTOBERSERK , SI_AUTOBERSERK , SCB_NONE ); + status->set_sc( NV_TRICKDEAD , SC_TRICKDEAD , SI_TRICKDEAD , SCB_REGEN ); + status->set_sc( SM_AUTOBERSERK , SC_AUTOBERSERK , SI_AUTOBERSERK , SCB_NONE ); add_sc( TF_SPRINKLESAND , SC_BLIND ); add_sc( TF_THROWSTONE , SC_STUN ); - set_sc( MC_LOUD , SC_SHOUT , SI_SHOUT , SCB_STR ); - set_sc( MG_ENERGYCOAT , SC_ENERGYCOAT , SI_ENERGYCOAT , SCB_NONE ); - set_sc( NPC_EMOTION , SC_MODECHANGE , SI_BLANK , SCB_MODE ); + status->set_sc( MC_LOUD , SC_SHOUT , SI_SHOUT , SCB_STR ); + status->set_sc( MG_ENERGYCOAT , SC_ENERGYCOAT , SI_ENERGYCOAT , SCB_NONE ); + status->set_sc( NPC_EMOTION , SC_MODECHANGE , SI_BLANK , SCB_MODE ); add_sc( NPC_EMOTION_ON , SC_MODECHANGE ); - set_sc( NPC_ATTRICHANGE , SC_ARMOR_PROPERTY , SI_ARMOR_PROPERTY , SCB_DEF_ELE ); + status->set_sc( NPC_ATTRICHANGE , SC_ARMOR_PROPERTY , SI_ARMOR_PROPERTY , SCB_DEF_ELE ); add_sc( NPC_CHANGEWATER , SC_ARMOR_PROPERTY ); add_sc( NPC_CHANGEGROUND , SC_ARMOR_PROPERTY ); add_sc( NPC_CHANGEFIRE , SC_ARMOR_PROPERTY ); @@ -260,184 +261,184 @@ void initChangeTables(void) { add_sc( NPC_CURSEATTACK , SC_CURSE ); add_sc( NPC_SLEEPATTACK , SC_SLEEP ); add_sc( NPC_MAGICALATTACK , SC_MAGICALATTACK ); - set_sc( NPC_KEEPING , SC_KEEPING , SI_BLANK , SCB_DEF ); + status->set_sc( NPC_KEEPING , SC_KEEPING , SI_BLANK , SCB_DEF ); add_sc( NPC_DARKBLESSING , SC_COMA ); - set_sc( NPC_BARRIER , SC_BARRIER , SI_BLANK , SCB_MDEF|SCB_DEF ); + status->set_sc( NPC_BARRIER , SC_BARRIER , SI_BLANK , SCB_MDEF|SCB_DEF ); add_sc( NPC_DEFENDER , SC_ARMOR ); add_sc( NPC_LICK , SC_STUN ); - set_sc( NPC_HALLUCINATION , SC_ILLUSION , SI_ILLUSION , SCB_NONE ); + status->set_sc( NPC_HALLUCINATION , SC_ILLUSION , SI_ILLUSION , SCB_NONE ); add_sc( NPC_REBIRTH , SC_REBIRTH ); add_sc( RG_RAID , SC_STUN ); #ifdef RENEWAL add_sc( RG_RAID , SC_RAID ); add_sc( RG_BACKSTAP , SC_STUN ); #endif - set_sc( RG_STRIPWEAPON , SC_NOEQUIPWEAPON , SI_NOEQUIPWEAPON , SCB_WATK ); - set_sc( RG_STRIPSHIELD , SC_NOEQUIPSHIELD , SI_NOEQUIPSHIELD , SCB_DEF ); - set_sc( RG_STRIPARMOR , SC_NOEQUIPARMOR , SI_NOEQUIPARMOR , SCB_VIT ); - set_sc( RG_STRIPHELM , SC_NOEQUIPHELM , SI_NOEQUIPHELM , SCB_INT ); + status->set_sc( RG_STRIPWEAPON , SC_NOEQUIPWEAPON , SI_NOEQUIPWEAPON , SCB_WATK ); + status->set_sc( RG_STRIPSHIELD , SC_NOEQUIPSHIELD , SI_NOEQUIPSHIELD , SCB_DEF ); + status->set_sc( RG_STRIPARMOR , SC_NOEQUIPARMOR , SI_NOEQUIPARMOR , SCB_VIT ); + status->set_sc( RG_STRIPHELM , SC_NOEQUIPHELM , SI_NOEQUIPHELM , SCB_INT ); add_sc( AM_ACIDTERROR , SC_BLOODING ); - set_sc( AM_CP_WEAPON , SC_PROTECTWEAPON , SI_PROTECTWEAPON , SCB_NONE ); - set_sc( AM_CP_SHIELD , SC_PROTECTSHIELD , SI_PROTECTSHIELD , SCB_NONE ); - set_sc( AM_CP_ARMOR , SC_PROTECTARMOR , SI_PROTECTARMOR , SCB_NONE ); - set_sc( AM_CP_HELM , SC_PROTECTHELM , SI_PROTECTHELM , SCB_NONE ); - set_sc( CR_AUTOGUARD , SC_AUTOGUARD , SI_AUTOGUARD , SCB_NONE ); + status->set_sc( AM_CP_WEAPON , SC_PROTECTWEAPON , SI_PROTECTWEAPON , SCB_NONE ); + status->set_sc( AM_CP_SHIELD , SC_PROTECTSHIELD , SI_PROTECTSHIELD , SCB_NONE ); + status->set_sc( AM_CP_ARMOR , SC_PROTECTARMOR , SI_PROTECTARMOR , SCB_NONE ); + status->set_sc( AM_CP_HELM , SC_PROTECTHELM , SI_PROTECTHELM , SCB_NONE ); + status->set_sc( CR_AUTOGUARD , SC_AUTOGUARD , SI_AUTOGUARD , SCB_NONE ); add_sc( CR_SHIELDCHARGE , SC_STUN ); - set_sc( CR_REFLECTSHIELD , SC_REFLECTSHIELD , SI_REFLECTSHIELD , SCB_NONE ); + status->set_sc( CR_REFLECTSHIELD , SC_REFLECTSHIELD , SI_REFLECTSHIELD , SCB_NONE ); add_sc( CR_HOLYCROSS , SC_BLIND ); add_sc( CR_GRANDCROSS , SC_BLIND ); add_sc( CR_DEVOTION , SC_DEVOTION ); - set_sc( CR_PROVIDENCE , SC_PROVIDENCE , SI_PROVIDENCE , SCB_ALL ); - set_sc( CR_DEFENDER , SC_DEFENDER , SI_DEFENDER , SCB_SPEED|SCB_ASPD ); - set_sc( CR_SPEARQUICKEN , SC_SPEARQUICKEN , SI_SPEARQUICKEN , SCB_ASPD|SCB_CRI|SCB_FLEE ); - set_sc( MO_STEELBODY , SC_STEELBODY , SI_STEELBODY , SCB_DEF|SCB_MDEF|SCB_ASPD|SCB_SPEED ); + status->set_sc( CR_PROVIDENCE , SC_PROVIDENCE , SI_PROVIDENCE , SCB_ALL ); + status->set_sc( CR_DEFENDER , SC_DEFENDER , SI_DEFENDER , SCB_SPEED|SCB_ASPD ); + status->set_sc( CR_SPEARQUICKEN , SC_SPEARQUICKEN , SI_SPEARQUICKEN , SCB_ASPD|SCB_CRI|SCB_FLEE ); + status->set_sc( MO_STEELBODY , SC_STEELBODY , SI_STEELBODY , SCB_DEF|SCB_MDEF|SCB_ASPD|SCB_SPEED ); add_sc( MO_BLADESTOP , SC_BLADESTOP_WAIT ); add_sc( MO_BLADESTOP , SC_BLADESTOP ); - set_sc( MO_EXPLOSIONSPIRITS , SC_EXPLOSIONSPIRITS, SI_EXPLOSIONSPIRITS, SCB_CRI|SCB_REGEN ); - set_sc( MO_EXTREMITYFIST , SC_EXTREMITYFIST , SI_BLANK , SCB_REGEN ); + status->set_sc( MO_EXPLOSIONSPIRITS , SC_EXPLOSIONSPIRITS, SI_EXPLOSIONSPIRITS, SCB_CRI|SCB_REGEN ); + status->set_sc( MO_EXTREMITYFIST , SC_EXTREMITYFIST , SI_BLANK , SCB_REGEN ); #ifdef RENEWAL - set_sc( MO_EXTREMITYFIST , SC_EXTREMITYFIST2 , SI_EXTREMITYFIST , SCB_NONE ); + status->set_sc( MO_EXTREMITYFIST , SC_EXTREMITYFIST2 , SI_EXTREMITYFIST , SCB_NONE ); #endif add_sc( SA_MAGICROD , SC_MAGICROD ); - set_sc( SA_AUTOSPELL , SC_AUTOSPELL , SI_AUTOSPELL , SCB_NONE ); - set_sc( SA_FLAMELAUNCHER , SC_PROPERTYFIRE , SI_PROPERTYFIRE , SCB_ATK_ELE ); - set_sc( SA_FROSTWEAPON , SC_PROPERTYWATER , SI_PROPERTYWATER , SCB_ATK_ELE ); - set_sc( SA_LIGHTNINGLOADER , SC_PROPERTYWIND , SI_PROPERTYWIND , SCB_ATK_ELE ); - set_sc( SA_SEISMICWEAPON , SC_PROPERTYGROUND , SI_PROPERTYGROUND , SCB_ATK_ELE ); - set_sc( SA_VOLCANO , SC_VOLCANO , SI_GROUNDMAGIC , SCB_WATK ); - set_sc( SA_DELUGE , SC_DELUGE , SI_GROUNDMAGIC , SCB_MAXHP ); - set_sc( SA_VIOLENTGALE , SC_VIOLENTGALE , SI_GROUNDMAGIC , SCB_FLEE ); + status->set_sc( SA_AUTOSPELL , SC_AUTOSPELL , SI_AUTOSPELL , SCB_NONE ); + status->set_sc( SA_FLAMELAUNCHER , SC_PROPERTYFIRE , SI_PROPERTYFIRE , SCB_ATK_ELE ); + status->set_sc( SA_FROSTWEAPON , SC_PROPERTYWATER , SI_PROPERTYWATER , SCB_ATK_ELE ); + status->set_sc( SA_LIGHTNINGLOADER , SC_PROPERTYWIND , SI_PROPERTYWIND , SCB_ATK_ELE ); + status->set_sc( SA_SEISMICWEAPON , SC_PROPERTYGROUND , SI_PROPERTYGROUND , SCB_ATK_ELE ); + status->set_sc( SA_VOLCANO , SC_VOLCANO , SI_GROUNDMAGIC , SCB_WATK ); + status->set_sc( SA_DELUGE , SC_DELUGE , SI_GROUNDMAGIC , SCB_MAXHP ); + status->set_sc( SA_VIOLENTGALE , SC_VIOLENTGALE , SI_GROUNDMAGIC , SCB_FLEE ); add_sc( SA_REVERSEORCISH , SC_ORCISH ); add_sc( SA_COMA , SC_COMA ); - set_sc( BD_ENCORE , SC_DANCING , SI_BLANK , SCB_SPEED|SCB_REGEN ); + status->set_sc( BD_ENCORE , SC_DANCING , SI_BLANK , SCB_SPEED|SCB_REGEN ); add_sc( BD_RICHMANKIM , SC_RICHMANKIM ); - set_sc( BD_ETERNALCHAOS , SC_ETERNALCHAOS , SI_BLANK , SCB_DEF2 ); - set_sc( BD_DRUMBATTLEFIELD , SC_DRUMBATTLE , SI_BLANK , SCB_WATK|SCB_DEF ); - set_sc( BD_RINGNIBELUNGEN , SC_NIBELUNGEN , SI_BLANK , SCB_WATK ); + status->set_sc( BD_ETERNALCHAOS , SC_ETERNALCHAOS , SI_BLANK , SCB_DEF2 ); + status->set_sc( BD_DRUMBATTLEFIELD , SC_DRUMBATTLE , SI_BLANK , SCB_WATK|SCB_DEF ); + status->set_sc( BD_RINGNIBELUNGEN , SC_NIBELUNGEN , SI_BLANK , SCB_WATK ); add_sc( BD_ROKISWEIL , SC_ROKISWEIL ); add_sc( BD_INTOABYSS , SC_INTOABYSS ); - set_sc( BD_SIEGFRIED , SC_SIEGFRIED , SI_BLANK , SCB_ALL ); + status->set_sc( BD_SIEGFRIED , SC_SIEGFRIED , SI_BLANK , SCB_ALL ); add_sc( BA_FROSTJOKER , SC_FREEZE ); - set_sc( BA_WHISTLE , SC_WHISTLE , SI_BLANK , SCB_FLEE|SCB_FLEE2 ); - set_sc( BA_ASSASSINCROSS , SC_ASSNCROS , SI_BLANK , SCB_ASPD ); + status->set_sc( BA_WHISTLE , SC_WHISTLE , SI_BLANK , SCB_FLEE|SCB_FLEE2 ); + status->set_sc( BA_ASSASSINCROSS , SC_ASSNCROS , SI_BLANK , SCB_ASPD ); add_sc( BA_POEMBRAGI , SC_POEMBRAGI ); - set_sc( BA_APPLEIDUN , SC_APPLEIDUN , SI_BLANK , SCB_MAXHP ); + status->set_sc( BA_APPLEIDUN , SC_APPLEIDUN , SI_BLANK , SCB_MAXHP ); add_sc( DC_SCREAM , SC_STUN ); - set_sc( DC_HUMMING , SC_HUMMING , SI_BLANK , SCB_HIT ); - set_sc( DC_DONTFORGETME , SC_DONTFORGETME , SI_BLANK , SCB_SPEED|SCB_ASPD ); - set_sc( DC_FORTUNEKISS , SC_FORTUNE , SI_BLANK , SCB_CRI ); - set_sc( DC_SERVICEFORYOU , SC_SERVICEFORYOU , SI_BLANK , SCB_ALL ); + status->set_sc( DC_HUMMING , SC_HUMMING , SI_BLANK , SCB_HIT ); + status->set_sc( DC_DONTFORGETME , SC_DONTFORGETME , SI_BLANK , SCB_SPEED|SCB_ASPD ); + status->set_sc( DC_FORTUNEKISS , SC_FORTUNE , SI_BLANK , SCB_CRI ); + status->set_sc( DC_SERVICEFORYOU , SC_SERVICEFORYOU , SI_BLANK , SCB_ALL ); add_sc( NPC_DARKCROSS , SC_BLIND ); add_sc( NPC_GRANDDARKNESS , SC_BLIND ); - set_sc( NPC_STOP , SC_STOP , SI_STOP , SCB_NONE ); - set_sc( NPC_WEAPONBRAKER , SC_BROKENWEAPON , SI_BROKENWEAPON , SCB_NONE ); - set_sc( NPC_ARMORBRAKE , SC_BROKENARMOR , SI_BROKENARMOR , SCB_NONE ); - set_sc( NPC_CHANGEUNDEAD , SC_PROPERTYUNDEAD , SI_PROPERTYUNDEAD , SCB_DEF_ELE ); - set_sc( NPC_POWERUP , SC_INCHITRATE , SI_BLANK , SCB_HIT ); - set_sc( NPC_AGIUP , SC_INCFLEERATE , SI_BLANK , SCB_FLEE ); + status->set_sc( NPC_STOP , SC_STOP , SI_STOP , SCB_NONE ); + status->set_sc( NPC_WEAPONBRAKER , SC_BROKENWEAPON , SI_BROKENWEAPON , SCB_NONE ); + status->set_sc( NPC_ARMORBRAKE , SC_BROKENARMOR , SI_BROKENARMOR , SCB_NONE ); + status->set_sc( NPC_CHANGEUNDEAD , SC_PROPERTYUNDEAD , SI_PROPERTYUNDEAD , SCB_DEF_ELE ); + status->set_sc( NPC_POWERUP , SC_INCHITRATE , SI_BLANK , SCB_HIT ); + status->set_sc( NPC_AGIUP , SC_INCFLEERATE , SI_BLANK , SCB_FLEE ); add_sc( NPC_INVISIBLE , SC_CLOAKING ); - set_sc( LK_AURABLADE , SC_AURABLADE , SI_AURABLADE , SCB_NONE ); - set_sc( LK_PARRYING , SC_PARRYING , SI_PARRYING , SCB_NONE ); + status->set_sc( LK_AURABLADE , SC_AURABLADE , SI_AURABLADE , SCB_NONE ); + status->set_sc( LK_PARRYING , SC_PARRYING , SI_PARRYING , SCB_NONE ); #ifndef RENEWAL - set_sc( LK_CONCENTRATION , SC_LKCONCENTRATION , SI_LKCONCENTRATION , SCB_BATK|SCB_WATK|SCB_HIT|SCB_DEF|SCB_DEF2); + status->set_sc( LK_CONCENTRATION , SC_LKCONCENTRATION , SI_LKCONCENTRATION , SCB_BATK|SCB_WATK|SCB_HIT|SCB_DEF|SCB_DEF2); #else - set_sc( LK_CONCENTRATION , SC_LKCONCENTRATION , SI_LKCONCENTRATION , SCB_HIT|SCB_DEF); + status->set_sc( LK_CONCENTRATION , SC_LKCONCENTRATION , SI_LKCONCENTRATION , SCB_HIT|SCB_DEF); #endif - set_sc( LK_TENSIONRELAX , SC_TENSIONRELAX , SI_TENSIONRELAX , SCB_REGEN ); - set_sc( LK_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN ); - set_sc( HP_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE ); + status->set_sc( LK_TENSIONRELAX , SC_TENSIONRELAX , SI_TENSIONRELAX , SCB_REGEN ); + status->set_sc( LK_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN ); + status->set_sc( HP_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE ); add_sc( HP_BASILICA , SC_BASILICA ); - set_sc( HW_MAGICPOWER , SC_MAGICPOWER , SI_MAGICPOWER , SCB_MATK ); + status->set_sc( HW_MAGICPOWER , SC_MAGICPOWER , SI_MAGICPOWER , SCB_MATK ); add_sc( PA_SACRIFICE , SC_SACRIFICE ); - set_sc( PA_GOSPEL , SC_GOSPEL , SI_BLANK , SCB_SPEED|SCB_ASPD ); + status->set_sc( PA_GOSPEL , SC_GOSPEL , SI_BLANK , SCB_SPEED|SCB_ASPD ); add_sc( PA_GOSPEL , SC_SCRESIST ); add_sc( CH_TIGERFIST , SC_STOP ); - set_sc( ASC_EDP , SC_EDP , SI_EDP , SCB_NONE ); - set_sc( SN_SIGHT , SC_TRUESIGHT , SI_TRUESIGHT , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK|SCB_CRI|SCB_HIT ); - set_sc( SN_WINDWALK , SC_WINDWALK , SI_WINDWALK , SCB_FLEE|SCB_SPEED ); - set_sc( WS_MELTDOWN , SC_MELTDOWN , SI_MELTDOWN , SCB_NONE ); - set_sc( WS_CARTBOOST , SC_CARTBOOST , SI_CARTBOOST , SCB_SPEED ); - set_sc( ST_CHASEWALK , SC_CHASEWALK , SI_BLANK , SCB_SPEED ); - set_sc( ST_REJECTSWORD , SC_SWORDREJECT , SI_SWORDREJECT , SCB_NONE ); + status->set_sc( ASC_EDP , SC_EDP , SI_EDP , SCB_NONE ); + status->set_sc( SN_SIGHT , SC_TRUESIGHT , SI_TRUESIGHT , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK|SCB_CRI|SCB_HIT ); + status->set_sc( SN_WINDWALK , SC_WINDWALK , SI_WINDWALK , SCB_FLEE|SCB_SPEED ); + status->set_sc( WS_MELTDOWN , SC_MELTDOWN , SI_MELTDOWN , SCB_NONE ); + status->set_sc( WS_CARTBOOST , SC_CARTBOOST , SI_CARTBOOST , SCB_SPEED ); + status->set_sc( ST_CHASEWALK , SC_CHASEWALK , SI_BLANK , SCB_SPEED ); + status->set_sc( ST_REJECTSWORD , SC_SWORDREJECT , SI_SWORDREJECT , SCB_NONE ); add_sc( ST_REJECTSWORD , SC_AUTOCOUNTER ); - set_sc( CG_MARIONETTE , SC_MARIONETTE_MASTER , SI_MARIONETTE_MASTER , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); - set_sc( CG_MARIONETTE , SC_MARIONETTE , SI_MARIONETTE , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); + status->set_sc( CG_MARIONETTE , SC_MARIONETTE_MASTER , SI_MARIONETTE_MASTER , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); + status->set_sc( CG_MARIONETTE , SC_MARIONETTE , SI_MARIONETTE , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); add_sc( LK_SPIRALPIERCE , SC_STOP ); add_sc( LK_HEADCRUSH , SC_BLOODING ); - set_sc( LK_JOINTBEAT , SC_JOINTBEAT , SI_JOINTBEAT , SCB_BATK|SCB_DEF2|SCB_SPEED|SCB_ASPD ); + status->set_sc( LK_JOINTBEAT , SC_JOINTBEAT , SI_JOINTBEAT , SCB_BATK|SCB_DEF2|SCB_SPEED|SCB_ASPD ); add_sc( HW_NAPALMVULCAN , SC_CURSE ); - set_sc( PF_MINDBREAKER , SC_MINDBREAKER , SI_BLANK , SCB_MATK|SCB_MDEF2 ); + status->set_sc( PF_MINDBREAKER , SC_MINDBREAKER , SI_BLANK , SCB_MATK|SCB_MDEF2 ); add_sc( PF_MEMORIZE , SC_MEMORIZE ); add_sc( PF_FOGWALL , SC_FOGWALL ); - set_sc( PF_SPIDERWEB , SC_SPIDERWEB , SI_BLANK , SCB_FLEE ); - set_sc( WE_BABY , SC_BABY , SI_PROTECTEXP , SCB_NONE ); - set_sc( TK_RUN , SC_RUN , SI_RUN , SCB_SPEED|SCB_DSPD ); - set_sc( TK_RUN , SC_STRUP , SI_STRUP , SCB_STR ); - set_sc( TK_READYSTORM , SC_STORMKICK_READY , SI_STORMKICK_ON , SCB_NONE ); - set_sc( TK_READYDOWN , SC_DOWNKICK_READY , SI_DOWNKICK_ON , SCB_NONE ); + status->set_sc( PF_SPIDERWEB , SC_SPIDERWEB , SI_BLANK , SCB_FLEE ); + status->set_sc( WE_BABY , SC_BABY , SI_PROTECTEXP , SCB_NONE ); + status->set_sc( TK_RUN , SC_RUN , SI_RUN , SCB_SPEED|SCB_DSPD ); + status->set_sc( TK_RUN , SC_STRUP , SI_STRUP , SCB_STR ); + status->set_sc( TK_READYSTORM , SC_STORMKICK_READY , SI_STORMKICK_ON , SCB_NONE ); + status->set_sc( TK_READYDOWN , SC_DOWNKICK_READY , SI_DOWNKICK_ON , SCB_NONE ); add_sc( TK_DOWNKICK , SC_STUN ); - set_sc( TK_READYTURN , SC_TURNKICK_READY , SI_TURNKICK_ON , SCB_NONE ); - set_sc( TK_READYCOUNTER , SC_COUNTERKICK_READY , SI_COUNTER_ON , SCB_NONE ); - set_sc( TK_DODGE , SC_DODGE_READY , SI_DODGE_ON , SCB_NONE ); - set_sc( TK_SPTIME , SC_EARTHSCROLL , SI_EARTHSCROLL , SCB_NONE ); + status->set_sc( TK_READYTURN , SC_TURNKICK_READY , SI_TURNKICK_ON , SCB_NONE ); + status->set_sc( TK_READYCOUNTER , SC_COUNTERKICK_READY , SI_COUNTER_ON , SCB_NONE ); + status->set_sc( TK_DODGE , SC_DODGE_READY , SI_DODGE_ON , SCB_NONE ); + status->set_sc( TK_SPTIME , SC_EARTHSCROLL , SI_EARTHSCROLL , SCB_NONE ); add_sc( TK_SEVENWIND , SC_TK_SEVENWIND ); - set_sc( TK_SEVENWIND , SC_PROPERTYTELEKINESIS , SI_PROPERTYTELEKINESIS , SCB_ATK_ELE ); - set_sc( TK_SEVENWIND , SC_PROPERTYDARK , SI_PROPERTYDARK , SCB_ATK_ELE ); - set_sc( SG_SUN_WARM , SC_WARM , SI_SG_SUN_WARM , SCB_NONE ); + status->set_sc( TK_SEVENWIND , SC_PROPERTYTELEKINESIS , SI_PROPERTYTELEKINESIS , SCB_ATK_ELE ); + status->set_sc( TK_SEVENWIND , SC_PROPERTYDARK , SI_PROPERTYDARK , SCB_ATK_ELE ); + status->set_sc( SG_SUN_WARM , SC_WARM , SI_SG_SUN_WARM , SCB_NONE ); add_sc( SG_MOON_WARM , SC_WARM ); add_sc( SG_STAR_WARM , SC_WARM ); - set_sc( SG_SUN_COMFORT , SC_SUN_COMFORT , SI_SUN_COMFORT , SCB_DEF2 ); - set_sc( SG_MOON_COMFORT , SC_MOON_COMFORT , SI_MOON_COMFORT , SCB_FLEE ); - set_sc( SG_STAR_COMFORT , SC_STAR_COMFORT , SI_STAR_COMFORT , SCB_ASPD ); + status->set_sc( SG_SUN_COMFORT , SC_SUN_COMFORT , SI_SUN_COMFORT , SCB_DEF2 ); + status->set_sc( SG_MOON_COMFORT , SC_MOON_COMFORT , SI_MOON_COMFORT , SCB_FLEE ); + status->set_sc( SG_STAR_COMFORT , SC_STAR_COMFORT , SI_STAR_COMFORT , SCB_ASPD ); add_sc( SG_FRIEND , SC_SKILLRATE_UP ); - set_sc( SG_KNOWLEDGE , SC_KNOWLEDGE , SI_BLANK , SCB_ALL ); - set_sc( SG_FUSION , SC_FUSION , SI_BLANK , SCB_SPEED ); - set_sc( BS_ADRENALINE2 , SC_ADRENALINE2 , SI_ADRENALINE2 , SCB_ASPD ); - set_sc( SL_KAIZEL , SC_KAIZEL , SI_KAIZEL , SCB_NONE ); - set_sc( SL_KAAHI , SC_KAAHI , SI_KAAHI , SCB_NONE ); - set_sc( SL_KAUPE , SC_KAUPE , SI_KAUPE , SCB_NONE ); - set_sc( SL_KAITE , SC_KAITE , SI_KAITE , SCB_NONE ); + status->set_sc( SG_KNOWLEDGE , SC_KNOWLEDGE , SI_BLANK , SCB_ALL ); + status->set_sc( SG_FUSION , SC_FUSION , SI_BLANK , SCB_SPEED ); + status->set_sc( BS_ADRENALINE2 , SC_ADRENALINE2 , SI_ADRENALINE2 , SCB_ASPD ); + status->set_sc( SL_KAIZEL , SC_KAIZEL , SI_KAIZEL , SCB_NONE ); + status->set_sc( SL_KAAHI , SC_KAAHI , SI_KAAHI , SCB_NONE ); + status->set_sc( SL_KAUPE , SC_KAUPE , SI_KAUPE , SCB_NONE ); + status->set_sc( SL_KAITE , SC_KAITE , SI_KAITE , SCB_NONE ); add_sc( SL_STUN , SC_STUN ); - set_sc( SL_SWOO , SC_SWOO , SI_BLANK , SCB_SPEED ); - set_sc( SL_SKE , SC_SKE , SI_BLANK , SCB_BATK|SCB_WATK|SCB_DEF|SCB_DEF2 ); - set_sc( SL_SKA , SC_SKA , SI_BLANK , SCB_DEF|SCB_MDEF|SCB_ASPD ); - set_sc( SL_SMA , SC_SMA_READY , SI_SMA_READY , SCB_NONE ); - set_sc( SM_SELFPROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); - set_sc( ST_PRESERVE , SC_PRESERVE , SI_PRESERVE , SCB_NONE ); - set_sc( PF_DOUBLECASTING , SC_DOUBLECASTING , SI_DOUBLECASTING , SCB_NONE ); - set_sc( HW_GRAVITATION , SC_GRAVITATION , SI_BLANK , SCB_ASPD ); + status->set_sc( SL_SWOO , SC_SWOO , SI_BLANK , SCB_SPEED ); + status->set_sc( SL_SKE , SC_SKE , SI_BLANK , SCB_BATK|SCB_WATK|SCB_DEF|SCB_DEF2 ); + status->set_sc( SL_SKA , SC_SKA , SI_BLANK , SCB_DEF|SCB_MDEF|SCB_ASPD ); + status->set_sc( SL_SMA , SC_SMA_READY , SI_SMA_READY , SCB_NONE ); + status->set_sc( SM_SELFPROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); + status->set_sc( ST_PRESERVE , SC_PRESERVE , SI_PRESERVE , SCB_NONE ); + status->set_sc( PF_DOUBLECASTING , SC_DOUBLECASTING , SI_DOUBLECASTING , SCB_NONE ); + status->set_sc( HW_GRAVITATION , SC_GRAVITATION , SI_BLANK , SCB_ASPD ); add_sc( WS_CARTTERMINATION , SC_STUN ); - set_sc( WS_OVERTHRUSTMAX , SC_OVERTHRUSTMAX , SI_OVERTHRUSTMAX , SCB_NONE ); - set_sc( CG_LONGINGFREEDOM , SC_LONGING , SI_BLANK , SCB_SPEED|SCB_ASPD ); + status->set_sc( WS_OVERTHRUSTMAX , SC_OVERTHRUSTMAX , SI_OVERTHRUSTMAX , SCB_NONE ); + status->set_sc( CG_LONGINGFREEDOM , SC_LONGING , SI_BLANK , SCB_SPEED|SCB_ASPD ); add_sc( CG_HERMODE , SC_HERMODE ); - set_sc( CG_TAROTCARD , SC_TAROTCARD , SI_TAROTCARD , SCB_NONE ); - set_sc( ITEM_ENCHANTARMS , SC_ENCHANTARMS , SI_BLANK , SCB_ATK_ELE ); - set_sc( SL_HIGH , SC_SOULLINK , SI_SOULLINK , SCB_ALL ); - set_sc( KN_ONEHAND , SC_ONEHANDQUICKEN , SI_ONEHANDQUICKEN , SCB_ASPD ); - set_sc( GS_FLING , SC_FLING , SI_BLANK , SCB_DEF|SCB_DEF2 ); + status->set_sc( CG_TAROTCARD , SC_TAROTCARD , SI_TAROTCARD , SCB_NONE ); + status->set_sc( ITEM_ENCHANTARMS , SC_ENCHANTARMS , SI_BLANK , SCB_ATK_ELE ); + status->set_sc( SL_HIGH , SC_SOULLINK , SI_SOULLINK , SCB_ALL ); + status->set_sc( KN_ONEHAND , SC_ONEHANDQUICKEN , SI_ONEHANDQUICKEN , SCB_ASPD ); + status->set_sc( GS_FLING , SC_FLING , SI_BLANK , SCB_DEF|SCB_DEF2 ); add_sc( GS_CRACKER , SC_STUN ); add_sc( GS_DISARM , SC_NOEQUIPWEAPON ); add_sc( GS_PIERCINGSHOT , SC_BLOODING ); - set_sc( GS_MADNESSCANCEL , SC_GS_MADNESSCANCEL , SI_GS_MADNESSCANCEL , SCB_ASPD + status->set_sc( GS_MADNESSCANCEL , SC_GS_MADNESSCANCEL , SI_GS_MADNESSCANCEL , SCB_ASPD #ifndef RENEWAL |SCB_BATK ); #else ); #endif - set_sc( GS_ADJUSTMENT , SC_GS_ADJUSTMENT , SI_GS_ADJUSTMENT , SCB_HIT|SCB_FLEE ); - set_sc( GS_INCREASING , SC_GS_ACCURACY , SI_GS_ACCURACY , SCB_AGI|SCB_DEX|SCB_HIT ); - set_sc( GS_GATLINGFEVER , SC_GS_GATLINGFEVER , SI_GS_GATLINGFEVER , SCB_FLEE|SCB_SPEED|SCB_ASPD + status->set_sc( GS_ADJUSTMENT , SC_GS_ADJUSTMENT , SI_GS_ADJUSTMENT , SCB_HIT|SCB_FLEE ); + status->set_sc( GS_INCREASING , SC_GS_ACCURACY , SI_GS_ACCURACY , SCB_AGI|SCB_DEX|SCB_HIT ); + status->set_sc( GS_GATLINGFEVER , SC_GS_GATLINGFEVER , SI_GS_GATLINGFEVER , SCB_FLEE|SCB_SPEED|SCB_ASPD #ifndef RENEWAL |SCB_BATK ); #else ); #endif - set_sc( NJ_TATAMIGAESHI , SC_NJ_TATAMIGAESHI , SI_BLANK , SCB_NONE ); - set_sc( NJ_SUITON , SC_NJ_SUITON , SI_NJ_SUITON , SCB_AGI|SCB_SPEED ); + status->set_sc( NJ_TATAMIGAESHI , SC_NJ_TATAMIGAESHI , SI_BLANK , SCB_NONE ); + status->set_sc( NJ_SUITON , SC_NJ_SUITON , SI_NJ_SUITON , SCB_AGI|SCB_SPEED ); add_sc( NJ_HYOUSYOURAKU , SC_FREEZE ); - set_sc( NJ_NEN , SC_NJ_NEN , SI_NJ_NEN , SCB_STR|SCB_INT ); - set_sc( NJ_UTSUSEMI , SC_NJ_UTSUSEMI , SI_NJ_UTSUSEMI , SCB_NONE ); - set_sc( NJ_BUNSINJYUTSU , SC_NJ_BUNSINJYUTSU , SI_NJ_BUNSINJYUTSU , SCB_DYE ); + status->set_sc( NJ_NEN , SC_NJ_NEN , SI_NJ_NEN , SCB_STR|SCB_INT ); + status->set_sc( NJ_UTSUSEMI , SC_NJ_UTSUSEMI , SI_NJ_UTSUSEMI , SCB_NONE ); + status->set_sc( NJ_BUNSINJYUTSU , SC_NJ_BUNSINJYUTSU , SI_NJ_BUNSINJYUTSU , SCB_DYE ); add_sc( NPC_ICEBREATH , SC_FREEZE ); add_sc( NPC_ACIDBREATH , SC_POISON ); @@ -451,201 +452,201 @@ void initChangeTables(void) { add_sc( NPC_WIDESIGHT , SC_SIGHT ); add_sc( NPC_EVILLAND , SC_BLIND ); add_sc( NPC_MAGICMIRROR , SC_MAGICMIRROR ); - set_sc( NPC_SLOWCAST , SC_SLOWCAST , SI_SLOWCAST , SCB_NONE ); - set_sc( NPC_CRITICALWOUND , SC_CRITICALWOUND , SI_CRITICALWOUND , SCB_NONE ); - set_sc( NPC_STONESKIN , SC_STONESKIN , SI_BLANK , SCB_DEF|SCB_MDEF ); + status->set_sc( NPC_SLOWCAST , SC_SLOWCAST , SI_SLOWCAST , SCB_NONE ); + status->set_sc( NPC_CRITICALWOUND , SC_CRITICALWOUND , SI_CRITICALWOUND , SCB_NONE ); + status->set_sc( NPC_STONESKIN , SC_STONESKIN , SI_BLANK , SCB_DEF|SCB_MDEF ); add_sc( NPC_ANTIMAGIC , SC_STONESKIN ); add_sc( NPC_WIDECURSE , SC_CURSE ); add_sc( NPC_WIDESTUN , SC_STUN ); - set_sc( NPC_HELLPOWER , SC_HELLPOWER , SI_HELLPOWER , SCB_NONE ); - set_sc( NPC_WIDEHELLDIGNITY , SC_HELLPOWER , SI_HELLPOWER , SCB_NONE ); - set_sc( NPC_INVINCIBLE , SC_INVINCIBLE , SI_INVINCIBLE , SCB_SPEED ); - set_sc( NPC_INVINCIBLEOFF , SC_INVINCIBLEOFF , SI_BLANK , SCB_SPEED ); + status->set_sc( NPC_HELLPOWER , SC_HELLPOWER , SI_HELLPOWER , SCB_NONE ); + status->set_sc( NPC_WIDEHELLDIGNITY , SC_HELLPOWER , SI_HELLPOWER , SCB_NONE ); + status->set_sc( NPC_INVINCIBLE , SC_INVINCIBLE , SI_INVINCIBLE , SCB_SPEED ); + status->set_sc( NPC_INVINCIBLEOFF , SC_INVINCIBLEOFF , SI_BLANK , SCB_SPEED ); - set_sc( CASH_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); - set_sc( CASH_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); - set_sc( CASH_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE ); + status->set_sc( CASH_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); + status->set_sc( CASH_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); + status->set_sc( CASH_ASSUMPTIO , SC_ASSUMPTIO , SI_ASSUMPTIO , SCB_NONE ); - set_sc( ALL_PARTYFLEE , SC_PARTYFLEE , SI_PARTYFLEE , SCB_NONE ); - set_sc( ALL_ODINS_POWER , SC_ODINS_POWER , SI_ODINS_POWER , SCB_WATK | SCB_MATK | SCB_MDEF | SCB_DEF); + status->set_sc( ALL_PARTYFLEE , SC_PARTYFLEE , SI_PARTYFLEE , SCB_NONE ); + status->set_sc( ALL_ODINS_POWER , SC_ODINS_POWER , SI_ODINS_POWER , SCB_WATK | SCB_MATK | SCB_MDEF | SCB_DEF); - set_sc( CR_SHRINK , SC_CR_SHRINK , SI_CR_SHRINK , SCB_NONE ); - set_sc( RG_CLOSECONFINE , SC_RG_CCONFINE_S , SI_RG_CCONFINE_S , SCB_NONE ); - set_sc( RG_CLOSECONFINE , SC_RG_CCONFINE_M , SI_RG_CCONFINE_M , SCB_FLEE ); - set_sc( WZ_SIGHTBLASTER , SC_WZ_SIGHTBLASTER , SI_WZ_SIGHTBLASTER , SCB_NONE ); - set_sc( DC_WINKCHARM , SC_DC_WINKCHARM , SI_DC_WINKCHARM , SCB_NONE ); + status->set_sc( CR_SHRINK , SC_CR_SHRINK , SI_CR_SHRINK , SCB_NONE ); + status->set_sc( RG_CLOSECONFINE , SC_RG_CCONFINE_S , SI_RG_CCONFINE_S , SCB_NONE ); + status->set_sc( RG_CLOSECONFINE , SC_RG_CCONFINE_M , SI_RG_CCONFINE_M , SCB_FLEE ); + status->set_sc( WZ_SIGHTBLASTER , SC_WZ_SIGHTBLASTER , SI_WZ_SIGHTBLASTER , SCB_NONE ); + status->set_sc( DC_WINKCHARM , SC_DC_WINKCHARM , SI_DC_WINKCHARM , SCB_NONE ); add_sc( MO_BALKYOUNG , SC_STUN ); add_sc( SA_ELEMENTWATER , SC_ARMOR_PROPERTY ); add_sc( SA_ELEMENTFIRE , SC_ARMOR_PROPERTY ); add_sc( SA_ELEMENTGROUND , SC_ARMOR_PROPERTY ); add_sc( SA_ELEMENTWIND , SC_ARMOR_PROPERTY ); - set_sc( HLIF_AVOID , SC_HLIF_AVOID , SI_BLANK , SCB_SPEED ); - set_sc( HLIF_CHANGE , SC_HLIF_CHANGE , SI_BLANK , SCB_VIT|SCB_INT ); - set_sc( HFLI_FLEET , SC_HLIF_FLEET , SI_BLANK , SCB_ASPD|SCB_BATK|SCB_WATK ); - set_sc( HFLI_SPEED , SC_HLIF_SPEED , SI_BLANK , SCB_FLEE ); - set_sc( HAMI_DEFENCE , SC_HAMI_DEFENCE , SI_BLANK , SCB_DEF ); - set_sc( HAMI_BLOODLUST , SC_HAMI_BLOODLUST , SI_BLANK , SCB_BATK|SCB_WATK ); + status->set_sc( HLIF_AVOID , SC_HLIF_AVOID , SI_BLANK , SCB_SPEED ); + status->set_sc( HLIF_CHANGE , SC_HLIF_CHANGE , SI_BLANK , SCB_VIT|SCB_INT ); + status->set_sc( HFLI_FLEET , SC_HLIF_FLEET , SI_BLANK , SCB_ASPD|SCB_BATK|SCB_WATK ); + status->set_sc( HFLI_SPEED , SC_HLIF_SPEED , SI_BLANK , SCB_FLEE ); + status->set_sc( HAMI_DEFENCE , SC_HAMI_DEFENCE , SI_BLANK , SCB_DEF ); + status->set_sc( HAMI_BLOODLUST , SC_HAMI_BLOODLUST , SI_BLANK , SCB_BATK|SCB_WATK ); // Homunculus S - set_sc( MH_LIGHT_OF_REGENE , SC_LIGHT_OF_REGENE , SI_LIGHT_OF_REGENE , SCB_NONE ); - set_sc( MH_OVERED_BOOST , SC_OVERED_BOOST , SI_OVERED_BOOST , SCB_FLEE|SCB_ASPD|SCB_DEF ); + status->set_sc( MH_LIGHT_OF_REGENE , SC_LIGHT_OF_REGENE , SI_LIGHT_OF_REGENE , SCB_NONE ); + status->set_sc( MH_OVERED_BOOST , SC_OVERED_BOOST , SI_OVERED_BOOST , SCB_FLEE|SCB_ASPD|SCB_DEF ); add_sc(MH_STAHL_HORN, SC_STUN); - set_sc(MH_ANGRIFFS_MODUS, SC_ANGRIFFS_MODUS, SI_ANGRIFFS_MODUS, SCB_BATK | SCB_DEF | SCB_FLEE | SCB_MAXHP); - set_sc(MH_GOLDENE_FERSE, SC_GOLDENE_FERSE, SI_GOLDENE_FERSE, SCB_ASPD|SCB_MAXHP); + status->set_sc(MH_ANGRIFFS_MODUS, SC_ANGRIFFS_MODUS, SI_ANGRIFFS_MODUS, SCB_BATK | SCB_DEF | SCB_FLEE | SCB_MAXHP); + status->set_sc(MH_GOLDENE_FERSE, SC_GOLDENE_FERSE, SI_GOLDENE_FERSE, SCB_ASPD|SCB_MAXHP); add_sc( MH_STEINWAND, SC_SAFETYWALL ); - set_sc(MH_VOLCANIC_ASH, SC_VOLCANIC_ASH, SI_VOLCANIC_ASH, SCB_DEF|SCB_DEF2|SCB_HIT|SCB_BATK|SCB_FLEE); - set_sc(MH_GRANITIC_ARMOR, SC_GRANITIC_ARMOR, SI_GRANITIC_ARMOR, SCB_NONE); - set_sc(MH_MAGMA_FLOW, SC_MAGMA_FLOW, SI_MAGMA_FLOW, SCB_NONE); - set_sc(MH_PYROCLASTIC, SC_PYROCLASTIC, SI_PYROCLASTIC, SCB_BATK|SCB_ATK_ELE); + status->set_sc(MH_VOLCANIC_ASH, SC_VOLCANIC_ASH, SI_VOLCANIC_ASH, SCB_DEF|SCB_DEF2|SCB_HIT|SCB_BATK|SCB_FLEE); + status->set_sc(MH_GRANITIC_ARMOR, SC_GRANITIC_ARMOR, SI_GRANITIC_ARMOR, SCB_NONE); + status->set_sc(MH_MAGMA_FLOW, SC_MAGMA_FLOW, SI_MAGMA_FLOW, SCB_NONE); + status->set_sc(MH_PYROCLASTIC, SC_PYROCLASTIC, SI_PYROCLASTIC, SCB_BATK|SCB_ATK_ELE); add_sc(MH_LAVA_SLIDE, SC_BURNING); - set_sc(MH_NEEDLE_OF_PARALYZE, SC_NEEDLE_OF_PARALYZE, SI_NEEDLE_OF_PARALYZE, SCB_DEF2); + status->set_sc(MH_NEEDLE_OF_PARALYZE, SC_NEEDLE_OF_PARALYZE, SI_NEEDLE_OF_PARALYZE, SCB_DEF2); add_sc(MH_POISON_MIST, SC_BLIND); - set_sc(MH_PAIN_KILLER, SC_PAIN_KILLER, SI_PAIN_KILLER, SCB_ASPD); + status->set_sc(MH_PAIN_KILLER, SC_PAIN_KILLER, SI_PAIN_KILLER, SCB_ASPD); - set_sc( MH_SILENT_BREEZE , SC_SILENCE , SI_SILENT_BREEZE , SCB_NONE ); + status->set_sc( MH_SILENT_BREEZE , SC_SILENCE , SI_SILENT_BREEZE , SCB_NONE ); add_sc( MH_STYLE_CHANGE , SC_STYLE_CHANGE); - set_sc( MH_TINDER_BREAKER , SC_RG_CCONFINE_S , SI_RG_CCONFINE_S , SCB_NONE ); - set_sc( MH_TINDER_BREAKER , SC_RG_CCONFINE_M , SI_RG_CCONFINE_M , SCB_FLEE ); + status->set_sc( MH_TINDER_BREAKER , SC_RG_CCONFINE_S , SI_RG_CCONFINE_S , SCB_NONE ); + status->set_sc( MH_TINDER_BREAKER , SC_RG_CCONFINE_M , SI_RG_CCONFINE_M , SCB_FLEE ); add_sc( MER_CRASH , SC_STUN ); - set_sc( MER_PROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); + status->set_sc( MER_PROVOKE , SC_PROVOKE , SI_PROVOKE , SCB_DEF|SCB_DEF2|SCB_BATK|SCB_WATK ); add_sc( MS_MAGNUM , SC_SUB_WEAPONPROPERTY ); add_sc( MER_SIGHT , SC_SIGHT ); - set_sc( MER_DECAGI , SC_DEC_AGI , SI_DEC_AGI , SCB_AGI|SCB_SPEED ); - set_sc( MER_MAGNIFICAT , SC_MAGNIFICAT , SI_MAGNIFICAT , SCB_REGEN ); + status->set_sc( MER_DECAGI , SC_DEC_AGI , SI_DEC_AGI , SCB_AGI|SCB_SPEED ); + status->set_sc( MER_MAGNIFICAT , SC_MAGNIFICAT , SI_MAGNIFICAT , SCB_REGEN ); add_sc( MER_LEXDIVINA , SC_SILENCE ); add_sc( MA_LANDMINE , SC_STUN ); add_sc( MA_SANDMAN , SC_SLEEP ); add_sc( MA_FREEZINGTRAP , SC_FREEZE ); - set_sc( MER_AUTOBERSERK , SC_AUTOBERSERK , SI_AUTOBERSERK , SCB_NONE ); - set_sc( ML_AUTOGUARD , SC_AUTOGUARD , SI_AUTOGUARD , SCB_NONE ); - set_sc( MS_REFLECTSHIELD , SC_REFLECTSHIELD , SI_REFLECTSHIELD , SCB_NONE ); - set_sc( ML_DEFENDER , SC_DEFENDER , SI_DEFENDER , SCB_SPEED|SCB_ASPD ); - set_sc( MS_PARRYING , SC_PARRYING , SI_PARRYING , SCB_NONE ); - set_sc( MS_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN ); + status->set_sc( MER_AUTOBERSERK , SC_AUTOBERSERK , SI_AUTOBERSERK , SCB_NONE ); + status->set_sc( ML_AUTOGUARD , SC_AUTOGUARD , SI_AUTOGUARD , SCB_NONE ); + status->set_sc( MS_REFLECTSHIELD , SC_REFLECTSHIELD , SI_REFLECTSHIELD , SCB_NONE ); + status->set_sc( ML_DEFENDER , SC_DEFENDER , SI_DEFENDER , SCB_SPEED|SCB_ASPD ); + status->set_sc( MS_PARRYING , SC_PARRYING , SI_PARRYING , SCB_NONE ); + status->set_sc( MS_BERSERK , SC_BERSERK , SI_BERSERK , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2|SCB_FLEE|SCB_SPEED|SCB_ASPD|SCB_MAXHP|SCB_REGEN ); add_sc( ML_SPIRALPIERCE , SC_STOP ); - set_sc( MER_QUICKEN , SC_MER_QUICKEN , SI_BLANK , SCB_ASPD ); + status->set_sc( MER_QUICKEN , SC_MER_QUICKEN , SI_BLANK , SCB_ASPD ); add_sc( ML_DEVOTION , SC_DEVOTION ); - set_sc( MER_KYRIE , SC_KYRIE , SI_KYRIE , SCB_NONE ); - set_sc( MER_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); - set_sc( MER_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); + status->set_sc( MER_KYRIE , SC_KYRIE , SI_KYRIE , SCB_NONE ); + status->set_sc( MER_BLESSING , SC_BLESSING , SI_BLESSING , SCB_STR|SCB_INT|SCB_DEX ); + status->set_sc( MER_INCAGI , SC_INC_AGI , SI_INC_AGI , SCB_AGI|SCB_SPEED ); - set_sc( GD_LEADERSHIP , SC_LEADERSHIP , SI_BLANK , SCB_STR ); - set_sc( GD_GLORYWOUNDS , SC_GLORYWOUNDS , SI_BLANK , SCB_VIT ); - set_sc( GD_SOULCOLD , SC_SOULCOLD , SI_BLANK , SCB_AGI ); - set_sc( GD_HAWKEYES , SC_HAWKEYES , SI_BLANK , SCB_DEX ); + status->set_sc( GD_LEADERSHIP , SC_LEADERSHIP , SI_BLANK , SCB_STR ); + status->set_sc( GD_GLORYWOUNDS , SC_GLORYWOUNDS , SI_BLANK , SCB_VIT ); + status->set_sc( GD_SOULCOLD , SC_SOULCOLD , SI_BLANK , SCB_AGI ); + status->set_sc( GD_HAWKEYES , SC_HAWKEYES , SI_BLANK , SCB_DEX ); - set_sc( GD_BATTLEORDER , SC_GDSKILL_BATTLEORDER , SI_BLANK , SCB_STR|SCB_INT|SCB_DEX ); - set_sc( GD_REGENERATION , SC_GDSKILL_REGENERATION , SI_BLANK , SCB_REGEN ); + status->set_sc( GD_BATTLEORDER , SC_GDSKILL_BATTLEORDER , SI_BLANK , SCB_STR|SCB_INT|SCB_DEX ); + status->set_sc( GD_REGENERATION , SC_GDSKILL_REGENERATION , SI_BLANK , SCB_REGEN ); /** * Rune Knight **/ - set_sc( RK_ENCHANTBLADE , SC_ENCHANTBLADE , SI_ENCHANTBLADE , SCB_NONE ); - set_sc( RK_DRAGONHOWLING , SC_FEAR , SI_BLANK , SCB_FLEE|SCB_HIT ); - set_sc( RK_DEATHBOUND , SC_DEATHBOUND , SI_DEATHBOUND , SCB_NONE ); - set_sc( RK_WINDCUTTER , SC_FEAR , SI_BLANK , SCB_FLEE|SCB_HIT ); + status->set_sc( RK_ENCHANTBLADE , SC_ENCHANTBLADE , SI_ENCHANTBLADE , SCB_NONE ); + status->set_sc( RK_DRAGONHOWLING , SC_FEAR , SI_BLANK , SCB_FLEE|SCB_HIT ); + status->set_sc( RK_DEATHBOUND , SC_DEATHBOUND , SI_DEATHBOUND , SCB_NONE ); + status->set_sc( RK_WINDCUTTER , SC_FEAR , SI_BLANK , SCB_FLEE|SCB_HIT ); add_sc( RK_DRAGONBREATH , SC_BURNING ); - set_sc( RK_MILLENNIUMSHIELD , SC_MILLENNIUMSHIELD , SI_BLANK , SCB_NONE ); - set_sc( RK_REFRESH , SC_REFRESH , SI_REFRESH , SCB_NONE ); - set_sc( RK_GIANTGROWTH , SC_GIANTGROWTH , SI_GIANTGROWTH , SCB_STR ); - set_sc( RK_STONEHARDSKIN , SC_STONEHARDSKIN , SI_STONEHARDSKIN , SCB_NONE ); - set_sc( RK_VITALITYACTIVATION, SC_VITALITYACTIVATION, SI_VITALITYACTIVATION, SCB_REGEN ); - set_sc( RK_FIGHTINGSPIRIT , SC_FIGHTINGSPIRIT , SI_FIGHTINGSPIRIT , SCB_WATK|SCB_ASPD ); - set_sc( RK_ABUNDANCE , SC_ABUNDANCE , SI_ABUNDANCE , SCB_NONE ); - set_sc( RK_CRUSHSTRIKE , SC_CRUSHSTRIKE , SI_CRUSHSTRIKE , SCB_NONE ); + status->set_sc( RK_MILLENNIUMSHIELD , SC_MILLENNIUMSHIELD , SI_BLANK , SCB_NONE ); + status->set_sc( RK_REFRESH , SC_REFRESH , SI_REFRESH , SCB_NONE ); + status->set_sc( RK_GIANTGROWTH , SC_GIANTGROWTH , SI_GIANTGROWTH , SCB_STR ); + status->set_sc( RK_STONEHARDSKIN , SC_STONEHARDSKIN , SI_STONEHARDSKIN , SCB_NONE ); + status->set_sc( RK_VITALITYACTIVATION, SC_VITALITYACTIVATION, SI_VITALITYACTIVATION, SCB_REGEN ); + status->set_sc( RK_FIGHTINGSPIRIT , SC_FIGHTINGSPIRIT , SI_FIGHTINGSPIRIT , SCB_WATK|SCB_ASPD ); + status->set_sc( RK_ABUNDANCE , SC_ABUNDANCE , SI_ABUNDANCE , SCB_NONE ); + status->set_sc( RK_CRUSHSTRIKE , SC_CRUSHSTRIKE , SI_CRUSHSTRIKE , SCB_NONE ); add_sc( RK_DRAGONBREATH_WATER, SC_FROSTMISTY ); /** * GC Guillotine Cross **/ set_sc_with_vfx( GC_VENOMIMPRESS , SC_VENOMIMPRESS , SI_VENOMIMPRESS , SCB_NONE ); - set_sc( GC_POISONINGWEAPON , SC_POISONINGWEAPON , SI_POISONINGWEAPON , SCB_NONE ); - set_sc( GC_WEAPONBLOCKING , SC_WEAPONBLOCKING , SI_WEAPONBLOCKING , SCB_NONE ); - set_sc( GC_CLOAKINGEXCEED , SC_CLOAKINGEXCEED , SI_CLOAKINGEXCEED , SCB_SPEED ); - set_sc( GC_HALLUCINATIONWALK , SC_HALLUCINATIONWALK, SI_HALLUCINATIONWALK, SCB_FLEE ); - set_sc( GC_ROLLINGCUTTER , SC_ROLLINGCUTTER , SI_ROLLINGCUTTER , SCB_NONE ); + status->set_sc( GC_POISONINGWEAPON , SC_POISONINGWEAPON , SI_POISONINGWEAPON , SCB_NONE ); + status->set_sc( GC_WEAPONBLOCKING , SC_WEAPONBLOCKING , SI_WEAPONBLOCKING , SCB_NONE ); + status->set_sc( GC_CLOAKINGEXCEED , SC_CLOAKINGEXCEED , SI_CLOAKINGEXCEED , SCB_SPEED ); + status->set_sc( GC_HALLUCINATIONWALK , SC_HALLUCINATIONWALK, SI_HALLUCINATIONWALK, SCB_FLEE ); + status->set_sc( GC_ROLLINGCUTTER , SC_ROLLINGCUTTER , SI_ROLLINGCUTTER , SCB_NONE ); set_sc_with_vfx( GC_DARKCROW , SC_DARKCROW , SI_DARKCROW , SCB_NONE ); /** * Arch Bishop **/ - set_sc( AB_ADORAMUS , SC_ADORAMUS , SI_ADORAMUS , SCB_AGI|SCB_SPEED ); + status->set_sc( AB_ADORAMUS , SC_ADORAMUS , SI_ADORAMUS , SCB_AGI|SCB_SPEED ); add_sc( AB_CLEMENTIA , SC_BLESSING ); add_sc( AB_CANTO , SC_INC_AGI ); - set_sc( AB_EPICLESIS , SC_EPICLESIS , SI_EPICLESIS , SCB_MAXHP ); + status->set_sc( AB_EPICLESIS , SC_EPICLESIS , SI_EPICLESIS , SCB_MAXHP ); add_sc( AB_PRAEFATIO , SC_KYRIE ); set_sc_with_vfx( AB_ORATIO , SC_ORATIO , SI_ORATIO , SCB_NONE ); - set_sc( AB_LAUDAAGNUS , SC_LAUDAAGNUS , SI_LAUDAAGNUS , SCB_VIT ); - set_sc( AB_LAUDARAMUS , SC_LAUDARAMUS , SI_LAUDARAMUS , SCB_LUK ); - set_sc( AB_RENOVATIO , SC_RENOVATIO , SI_RENOVATIO , SCB_REGEN ); - set_sc( AB_EXPIATIO , SC_EXPIATIO , SI_EXPIATIO , SCB_ATK_ELE ); - set_sc( AB_DUPLELIGHT , SC_DUPLELIGHT , SI_DUPLELIGHT , SCB_NONE ); - set_sc( AB_SECRAMENT , SC_SECRAMENT , SI_SECRAMENT , SCB_NONE ); - set_sc( AB_OFFERTORIUM , SC_OFFERTORIUM , SI_OFFERTORIUM , SCB_NONE ); + status->set_sc( AB_LAUDAAGNUS , SC_LAUDAAGNUS , SI_LAUDAAGNUS , SCB_VIT ); + status->set_sc( AB_LAUDARAMUS , SC_LAUDARAMUS , SI_LAUDARAMUS , SCB_LUK ); + status->set_sc( AB_RENOVATIO , SC_RENOVATIO , SI_RENOVATIO , SCB_REGEN ); + status->set_sc( AB_EXPIATIO , SC_EXPIATIO , SI_EXPIATIO , SCB_ATK_ELE ); + status->set_sc( AB_DUPLELIGHT , SC_DUPLELIGHT , SI_DUPLELIGHT , SCB_NONE ); + status->set_sc( AB_SECRAMENT , SC_SECRAMENT , SI_SECRAMENT , SCB_NONE ); + status->set_sc( AB_OFFERTORIUM , SC_OFFERTORIUM , SI_OFFERTORIUM , SCB_NONE ); /** * Warlock **/ add_sc( WL_WHITEIMPRISON , SC_WHITEIMPRISON ); set_sc_with_vfx( WL_FROSTMISTY , SC_FROSTMISTY , SI_FROSTMISTY , SCB_ASPD|SCB_SPEED|SCB_DEF ); - set_sc( WL_MARSHOFABYSS , SC_MARSHOFABYSS , SI_MARSHOFABYSS , SCB_SPEED|SCB_FLEE|SCB_AGI|SCB_DEX ); - set_sc(WL_RECOGNIZEDSPELL , SC_RECOGNIZEDSPELL , SI_RECOGNIZEDSPELL , SCB_MATK); - set_sc( WL_STASIS , SC_STASIS , SI_STASIS , SCB_NONE ); - set_sc( WL_TELEKINESIS_INTENSE, SC_TELEKINESIS_INTENSE , SI_TELEKINESIS_INTENSE , SCB_MATK ); + status->set_sc( WL_MARSHOFABYSS , SC_MARSHOFABYSS , SI_MARSHOFABYSS , SCB_SPEED|SCB_FLEE|SCB_AGI|SCB_DEX ); + status->set_sc(WL_RECOGNIZEDSPELL , SC_RECOGNIZEDSPELL , SI_RECOGNIZEDSPELL , SCB_MATK); + status->set_sc( WL_STASIS , SC_STASIS , SI_STASIS , SCB_NONE ); + status->set_sc( WL_TELEKINESIS_INTENSE, SC_TELEKINESIS_INTENSE , SI_TELEKINESIS_INTENSE , SCB_MATK ); /** * Ranger **/ - set_sc( RA_FEARBREEZE , SC_FEARBREEZE , SI_FEARBREEZE , SCB_NONE ); - set_sc( RA_ELECTRICSHOCKER , SC_ELECTRICSHOCKER , SI_ELECTRICSHOCKER , SCB_NONE ); - set_sc( RA_WUGDASH , SC_WUGDASH , SI_WUGDASH , SCB_SPEED ); - set_sc( RA_CAMOUFLAGE , SC_CAMOUFLAGE , SI_CAMOUFLAGE , SCB_SPEED ); + status->set_sc( RA_FEARBREEZE , SC_FEARBREEZE , SI_FEARBREEZE , SCB_NONE ); + status->set_sc( RA_ELECTRICSHOCKER , SC_ELECTRICSHOCKER , SI_ELECTRICSHOCKER , SCB_NONE ); + status->set_sc( RA_WUGDASH , SC_WUGDASH , SI_WUGDASH , SCB_SPEED ); + status->set_sc( RA_CAMOUFLAGE , SC_CAMOUFLAGE , SI_CAMOUFLAGE , SCB_SPEED ); add_sc( RA_MAGENTATRAP , SC_ARMOR_PROPERTY ); add_sc( RA_COBALTTRAP , SC_ARMOR_PROPERTY ); add_sc( RA_MAIZETRAP , SC_ARMOR_PROPERTY ); add_sc( RA_VERDURETRAP , SC_ARMOR_PROPERTY ); add_sc( RA_FIRINGTRAP , SC_BURNING ); add_sc( RA_ICEBOUNDTRAP , SC_FROSTMISTY ); - set_sc( RA_UNLIMIT , SC_UNLIMIT , SI_UNLIMIT , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2 ); + status->set_sc( RA_UNLIMIT , SC_UNLIMIT , SI_UNLIMIT , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2 ); /** * Mechanic **/ - set_sc( NC_ACCELERATION , SC_ACCELERATION , SI_ACCELERATION , SCB_SPEED ); - set_sc( NC_HOVERING , SC_HOVERING , SI_HOVERING , SCB_SPEED ); - set_sc( NC_SHAPESHIFT , SC_SHAPESHIFT , SI_SHAPESHIFT , SCB_DEF_ELE ); - set_sc( NC_INFRAREDSCAN , SC_INFRAREDSCAN , SI_INFRAREDSCAN , SCB_FLEE ); - set_sc( NC_ANALYZE , SC_ANALYZE , SI_ANALYZE , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2 ); - set_sc( NC_MAGNETICFIELD , SC_MAGNETICFIELD , SI_MAGNETICFIELD , SCB_NONE ); - set_sc( NC_NEUTRALBARRIER , SC_NEUTRALBARRIER , SI_NEUTRALBARRIER , SCB_DEF|SCB_MDEF ); - set_sc( NC_STEALTHFIELD , SC_STEALTHFIELD , SI_STEALTHFIELD , SCB_NONE ); + status->set_sc( NC_ACCELERATION , SC_ACCELERATION , SI_ACCELERATION , SCB_SPEED ); + status->set_sc( NC_HOVERING , SC_HOVERING , SI_HOVERING , SCB_SPEED ); + status->set_sc( NC_SHAPESHIFT , SC_SHAPESHIFT , SI_SHAPESHIFT , SCB_DEF_ELE ); + status->set_sc( NC_INFRAREDSCAN , SC_INFRAREDSCAN , SI_INFRAREDSCAN , SCB_FLEE ); + status->set_sc( NC_ANALYZE , SC_ANALYZE , SI_ANALYZE , SCB_DEF|SCB_DEF2|SCB_MDEF|SCB_MDEF2 ); + status->set_sc( NC_MAGNETICFIELD , SC_MAGNETICFIELD , SI_MAGNETICFIELD , SCB_NONE ); + status->set_sc( NC_NEUTRALBARRIER , SC_NEUTRALBARRIER , SI_NEUTRALBARRIER , SCB_DEF|SCB_MDEF ); + status->set_sc( NC_STEALTHFIELD , SC_STEALTHFIELD , SI_STEALTHFIELD , SCB_NONE ); /** * Royal Guard **/ - set_sc( LG_REFLECTDAMAGE , SC_LG_REFLECTDAMAGE , SI_LG_REFLECTDAMAGE, SCB_NONE ); - set_sc( LG_FORCEOFVANGUARD , SC_FORCEOFVANGUARD , SI_FORCEOFVANGUARD , SCB_MAXHP ); - set_sc( LG_EXEEDBREAK , SC_EXEEDBREAK , SI_EXEEDBREAK , SCB_NONE ); - set_sc( LG_PRESTIGE , SC_PRESTIGE , SI_PRESTIGE , SCB_DEF ); - set_sc( LG_BANDING , SC_BANDING , SI_BANDING , SCB_DEF2|SCB_WATK );// Renewal: atk2 & def2 - set_sc( LG_PIETY , SC_BENEDICTIO , SI_BENEDICTIO , SCB_DEF_ELE ); - set_sc( LG_EARTHDRIVE , SC_EARTHDRIVE , SI_EARTHDRIVE , SCB_DEF|SCB_ASPD ); - set_sc( LG_INSPIRATION , SC_INSPIRATION , SI_INSPIRATION , SCB_MAXHP|SCB_WATK|SCB_HIT|SCB_VIT|SCB_AGI|SCB_STR|SCB_DEX|SCB_INT|SCB_LUK); - set_sc( LG_KINGS_GRACE , SC_KINGS_GRACE , SI_KINGS_GRACE , SCB_NONE ); + status->set_sc( LG_REFLECTDAMAGE , SC_LG_REFLECTDAMAGE , SI_LG_REFLECTDAMAGE, SCB_NONE ); + status->set_sc( LG_FORCEOFVANGUARD , SC_FORCEOFVANGUARD , SI_FORCEOFVANGUARD , SCB_MAXHP ); + status->set_sc( LG_EXEEDBREAK , SC_EXEEDBREAK , SI_EXEEDBREAK , SCB_NONE ); + status->set_sc( LG_PRESTIGE , SC_PRESTIGE , SI_PRESTIGE , SCB_DEF ); + status->set_sc( LG_BANDING , SC_BANDING , SI_BANDING , SCB_DEF2|SCB_WATK );// Renewal: atk2 & def2 + status->set_sc( LG_PIETY , SC_BENEDICTIO , SI_BENEDICTIO , SCB_DEF_ELE ); + status->set_sc( LG_EARTHDRIVE , SC_EARTHDRIVE , SI_EARTHDRIVE , SCB_DEF|SCB_ASPD ); + status->set_sc( LG_INSPIRATION , SC_INSPIRATION , SI_INSPIRATION , SCB_MAXHP|SCB_WATK|SCB_HIT|SCB_VIT|SCB_AGI|SCB_STR|SCB_DEX|SCB_INT|SCB_LUK); + status->set_sc( LG_KINGS_GRACE , SC_KINGS_GRACE , SI_KINGS_GRACE , SCB_NONE ); /** * Shadow Chaser **/ - set_sc( SC_REPRODUCE , SC__REPRODUCE , SI_REPRODUCE , SCB_NONE ); - set_sc( SC_AUTOSHADOWSPELL , SC__AUTOSHADOWSPELL, SI_AUTOSHADOWSPELL , SCB_NONE ); - set_sc( SC_SHADOWFORM , SC__SHADOWFORM , SI_SHADOWFORM , SCB_NONE ); - set_sc( SC_BODYPAINT , SC__BODYPAINT , SI_BODYPAINT , SCB_ASPD ); - set_sc( SC_INVISIBILITY , SC__INVISIBILITY , SI_INVISIBILITY , SCB_ASPD|SCB_CRI|SCB_ATK_ELE ); - set_sc( SC_DEADLYINFECT , SC__DEADLYINFECT , SI_DEADLYINFECT , SCB_NONE ); - set_sc( SC_ENERVATION , SC__ENERVATION , SI_ENERVATION , SCB_BATK ); - set_sc( SC_GROOMY , SC__GROOMY , SI_GROOMY , SCB_ASPD|SCB_HIT|SCB_SPEED ); - set_sc( SC_IGNORANCE , SC__IGNORANCE , SI_IGNORANCE , SCB_NONE ); - set_sc( SC_LAZINESS , SC__LAZINESS , SI_LAZINESS , SCB_FLEE ); - set_sc( SC_UNLUCKY , SC__UNLUCKY , SI_UNLUCKY , SCB_CRI|SCB_FLEE2 ); - set_sc( SC_WEAKNESS , SC__WEAKNESS , SI_WEAKNESS , SCB_FLEE2|SCB_MAXHP ); - set_sc( SC_STRIPACCESSARY , SC__STRIPACCESSARY , SI_STRIPACCESSARY , SCB_DEX|SCB_INT|SCB_LUK ); + status->set_sc( SC_REPRODUCE , SC__REPRODUCE , SI_REPRODUCE , SCB_NONE ); + status->set_sc( SC_AUTOSHADOWSPELL , SC__AUTOSHADOWSPELL, SI_AUTOSHADOWSPELL , SCB_NONE ); + status->set_sc( SC_SHADOWFORM , SC__SHADOWFORM , SI_SHADOWFORM , SCB_NONE ); + status->set_sc( SC_BODYPAINT , SC__BODYPAINT , SI_BODYPAINT , SCB_ASPD ); + status->set_sc( SC_INVISIBILITY , SC__INVISIBILITY , SI_INVISIBILITY , SCB_ASPD|SCB_CRI|SCB_ATK_ELE ); + status->set_sc( SC_DEADLYINFECT , SC__DEADLYINFECT , SI_DEADLYINFECT , SCB_NONE ); + status->set_sc( SC_ENERVATION , SC__ENERVATION , SI_ENERVATION , SCB_BATK ); + status->set_sc( SC_GROOMY , SC__GROOMY , SI_GROOMY , SCB_ASPD|SCB_HIT|SCB_SPEED ); + status->set_sc( SC_IGNORANCE , SC__IGNORANCE , SI_IGNORANCE , SCB_NONE ); + status->set_sc( SC_LAZINESS , SC__LAZINESS , SI_LAZINESS , SCB_FLEE ); + status->set_sc( SC_UNLUCKY , SC__UNLUCKY , SI_UNLUCKY , SCB_CRI|SCB_FLEE2 ); + status->set_sc( SC_WEAKNESS , SC__WEAKNESS , SI_WEAKNESS , SCB_FLEE2|SCB_MAXHP ); + status->set_sc( SC_STRIPACCESSARY , SC__STRIPACCESSARY , SI_STRIPACCESSARY , SCB_DEX|SCB_INT|SCB_LUK ); set_sc_with_vfx( SC_MANHOLE , SC__MANHOLE , SI_MANHOLE , SCB_NONE ); add_sc( SC_CHAOSPANIC , SC__CHAOS ); add_sc( SC_MAELSTROM , SC__MAELSTROM ); @@ -656,113 +657,113 @@ void initChangeTables(void) { **/ add_sc( SR_DRAGONCOMBO , SC_STUN ); add_sc( SR_EARTHSHAKER , SC_STUN ); - set_sc( SR_FALLENEMPIRE , SC_FALLENEMPIRE , SI_FALLENEMPIRE , SCB_NONE ); - set_sc( SR_CRESCENTELBOW , SC_CRESCENTELBOW , SI_CRESCENTELBOW , SCB_NONE ); + status->set_sc( SR_FALLENEMPIRE , SC_FALLENEMPIRE , SI_FALLENEMPIRE , SCB_NONE ); + status->set_sc( SR_CRESCENTELBOW , SC_CRESCENTELBOW , SI_CRESCENTELBOW , SCB_NONE ); set_sc_with_vfx( SR_CURSEDCIRCLE , SC_CURSEDCIRCLE_TARGET, SI_CURSEDCIRCLE_TARGET , SCB_NONE ); - set_sc( SR_LIGHTNINGWALK , SC_LIGHTNINGWALK , SI_LIGHTNINGWALK , SCB_NONE ); - set_sc( SR_RAISINGDRAGON , SC_RAISINGDRAGON , SI_RAISINGDRAGON , SCB_REGEN|SCB_MAXHP|SCB_MAXSP ); - set_sc( SR_GENTLETOUCH_ENERGYGAIN, SC_GENTLETOUCH_ENERGYGAIN , SI_GENTLETOUCH_ENERGYGAIN, SCB_NONE ); - set_sc( SR_GENTLETOUCH_CHANGE , SC_GENTLETOUCH_CHANGE , SI_GENTLETOUCH_CHANGE , SCB_ASPD|SCB_MDEF|SCB_MAXHP ); - set_sc( SR_GENTLETOUCH_REVITALIZE, SC_GENTLETOUCH_REVITALIZE , SI_GENTLETOUCH_REVITALIZE, SCB_MAXHP|SCB_DEF2|SCB_REGEN ); - set_sc( SR_FLASHCOMBO , SC_FLASHCOMBO , SI_FLASHCOMBO , SCB_WATK ); + status->set_sc( SR_LIGHTNINGWALK , SC_LIGHTNINGWALK , SI_LIGHTNINGWALK , SCB_NONE ); + status->set_sc( SR_RAISINGDRAGON , SC_RAISINGDRAGON , SI_RAISINGDRAGON , SCB_REGEN|SCB_MAXHP|SCB_MAXSP ); + status->set_sc( SR_GENTLETOUCH_ENERGYGAIN, SC_GENTLETOUCH_ENERGYGAIN , SI_GENTLETOUCH_ENERGYGAIN, SCB_NONE ); + status->set_sc( SR_GENTLETOUCH_CHANGE , SC_GENTLETOUCH_CHANGE , SI_GENTLETOUCH_CHANGE , SCB_ASPD|SCB_MDEF|SCB_MAXHP ); + status->set_sc( SR_GENTLETOUCH_REVITALIZE, SC_GENTLETOUCH_REVITALIZE , SI_GENTLETOUCH_REVITALIZE, SCB_MAXHP|SCB_DEF2|SCB_REGEN ); + status->set_sc( SR_FLASHCOMBO , SC_FLASHCOMBO , SI_FLASHCOMBO , SCB_WATK ); /** * Wanderer / Minstrel **/ - set_sc( WA_SWING_DANCE , SC_SWING , SI_SWINGDANCE , SCB_SPEED|SCB_ASPD ); - set_sc( WA_SYMPHONY_OF_LOVER , SC_SYMPHONY_LOVE , SI_SYMPHONYOFLOVERS , SCB_MDEF ); - set_sc( WA_MOONLIT_SERENADE , SC_MOONLIT_SERENADE , SI_MOONLITSERENADE , SCB_MATK ); - set_sc( MI_RUSH_WINDMILL , SC_RUSH_WINDMILL , SI_RUSHWINDMILL , SCB_WATK ); - set_sc( MI_ECHOSONG , SC_ECHOSONG , SI_ECHOSONG , SCB_DEF2 ); - set_sc( MI_HARMONIZE , SC_HARMONIZE , SI_HARMONIZE , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); + status->set_sc( WA_SWING_DANCE , SC_SWING , SI_SWINGDANCE , SCB_SPEED|SCB_ASPD ); + status->set_sc( WA_SYMPHONY_OF_LOVER , SC_SYMPHONY_LOVE , SI_SYMPHONYOFLOVERS , SCB_MDEF ); + status->set_sc( WA_MOONLIT_SERENADE , SC_MOONLIT_SERENADE , SI_MOONLITSERENADE , SCB_MATK ); + status->set_sc( MI_RUSH_WINDMILL , SC_RUSH_WINDMILL , SI_RUSHWINDMILL , SCB_WATK ); + status->set_sc( MI_ECHOSONG , SC_ECHOSONG , SI_ECHOSONG , SCB_DEF2 ); + status->set_sc( MI_HARMONIZE , SC_HARMONIZE , SI_HARMONIZE , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); set_sc_with_vfx(WM_POEMOFNETHERWORLD, SC_NETHERWORLD , SI_NETHERWORLD , SCB_NONE); set_sc_with_vfx( WM_VOICEOFSIREN , SC_SIREN , SI_SIREN , SCB_NONE ); set_sc_with_vfx( WM_LULLABY_DEEPSLEEP , SC_DEEP_SLEEP , SI_DEEPSLEEP , SCB_NONE ); - set_sc( WM_SIRCLEOFNATURE , SC_SIRCLEOFNATURE , SI_SIRCLEOFNATURE , SCB_NONE ); - set_sc( WM_GLOOMYDAY , SC_GLOOMYDAY , SI_GLOOMYDAY , SCB_FLEE|SCB_ASPD ); - set_sc( WM_SONG_OF_MANA , SC_SONG_OF_MANA , SI_SONG_OF_MANA , SCB_NONE ); - set_sc( WM_DANCE_WITH_WUG , SC_DANCE_WITH_WUG , SI_DANCEWITHWUG , SCB_ASPD ); - set_sc( WM_SATURDAY_NIGHT_FEVER , SC_SATURDAY_NIGHT_FEVER , SI_SATURDAYNIGHTFEVER , SCB_BATK|SCB_DEF|SCB_FLEE|SCB_REGEN ); - set_sc( WM_LERADS_DEW , SC_LERADS_DEW , SI_LERADSDEW , SCB_MAXHP ); - set_sc( WM_MELODYOFSINK , SC_MELODYOFSINK , SI_MELODYOFSINK , SCB_INT ); - set_sc( WM_BEYOND_OF_WARCRY , SC_BEYOND_OF_WARCRY , SI_WARCRYOFBEYOND , SCB_STR|SCB_CRI|SCB_MAXHP ); - set_sc( WM_UNLIMITED_HUMMING_VOICE, SC_UNLIMITED_HUMMING_VOICE, SI_UNLIMITEDHUMMINGVOICE, SCB_NONE ); - set_sc( WM_FRIGG_SONG , SC_FRIGG_SONG , SI_FRIGG_SONG , SCB_MAXHP ); + status->set_sc( WM_SIRCLEOFNATURE , SC_SIRCLEOFNATURE , SI_SIRCLEOFNATURE , SCB_NONE ); + status->set_sc( WM_GLOOMYDAY , SC_GLOOMYDAY , SI_GLOOMYDAY , SCB_FLEE|SCB_ASPD ); + status->set_sc( WM_SONG_OF_MANA , SC_SONG_OF_MANA , SI_SONG_OF_MANA , SCB_NONE ); + status->set_sc( WM_DANCE_WITH_WUG , SC_DANCE_WITH_WUG , SI_DANCEWITHWUG , SCB_ASPD ); + status->set_sc( WM_SATURDAY_NIGHT_FEVER , SC_SATURDAY_NIGHT_FEVER , SI_SATURDAYNIGHTFEVER , SCB_BATK|SCB_DEF|SCB_FLEE|SCB_REGEN ); + status->set_sc( WM_LERADS_DEW , SC_LERADS_DEW , SI_LERADSDEW , SCB_MAXHP ); + status->set_sc( WM_MELODYOFSINK , SC_MELODYOFSINK , SI_MELODYOFSINK , SCB_INT ); + status->set_sc( WM_BEYOND_OF_WARCRY , SC_BEYOND_OF_WARCRY , SI_WARCRYOFBEYOND , SCB_STR|SCB_CRI|SCB_MAXHP ); + status->set_sc( WM_UNLIMITED_HUMMING_VOICE, SC_UNLIMITED_HUMMING_VOICE, SI_UNLIMITEDHUMMINGVOICE, SCB_NONE ); + status->set_sc( WM_FRIGG_SONG , SC_FRIGG_SONG , SI_FRIGG_SONG , SCB_MAXHP ); /** * Sorcerer **/ - set_sc( SO_FIREWALK , SC_PROPERTYWALK , SI_PROPERTYWALK , SCB_NONE ); - set_sc( SO_ELECTRICWALK , SC_PROPERTYWALK , SI_PROPERTYWALK , SCB_NONE ); - set_sc( SO_SPELLFIST , SC_SPELLFIST , SI_SPELLFIST , SCB_NONE ); + status->set_sc( SO_FIREWALK , SC_PROPERTYWALK , SI_PROPERTYWALK , SCB_NONE ); + status->set_sc( SO_ELECTRICWALK , SC_PROPERTYWALK , SI_PROPERTYWALK , SCB_NONE ); + status->set_sc( SO_SPELLFIST , SC_SPELLFIST , SI_SPELLFIST , SCB_NONE ); set_sc_with_vfx( SO_DIAMONDDUST , SC_COLD , SI_COLD , SCB_NONE ); // it does show the snow icon on mobs but doesn't affect it. - set_sc( SO_CLOUD_KILL , SC_POISON , SI_CLOUDKILL , SCB_NONE ); - set_sc( SO_STRIKING , SC_STRIKING , SI_STRIKING , SCB_WATK|SCB_CRI ); + status->set_sc( SO_CLOUD_KILL , SC_POISON , SI_CLOUDKILL , SCB_NONE ); + status->set_sc( SO_STRIKING , SC_STRIKING , SI_STRIKING , SCB_WATK|SCB_CRI ); add_sc( SO_WARMER , SC_WARMER ); // At the moment, no icon on officials - set_sc( SO_VACUUM_EXTREME , SC_VACUUM_EXTREME , SI_VACUUM_EXTREME , SCB_NONE ); - set_sc( SO_ARRULLO , SC_DEEP_SLEEP , SI_DEEPSLEEP , SCB_NONE ); - set_sc( SO_FIRE_INSIGNIA , SC_FIRE_INSIGNIA , SI_FIRE_INSIGNIA , SCB_MATK | SCB_BATK | SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); - set_sc( SO_WATER_INSIGNIA , SC_WATER_INSIGNIA , SI_WATER_INSIGNIA , SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); - set_sc( SO_WIND_INSIGNIA , SC_WIND_INSIGNIA , SI_WIND_INSIGNIA , SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); - set_sc( SO_EARTH_INSIGNIA , SC_EARTH_INSIGNIA , SI_EARTH_INSIGNIA , SCB_MDEF|SCB_DEF|SCB_MAXHP|SCB_MAXSP|SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); + status->set_sc( SO_VACUUM_EXTREME , SC_VACUUM_EXTREME , SI_VACUUM_EXTREME , SCB_NONE ); + status->set_sc( SO_ARRULLO , SC_DEEP_SLEEP , SI_DEEPSLEEP , SCB_NONE ); + status->set_sc( SO_FIRE_INSIGNIA , SC_FIRE_INSIGNIA , SI_FIRE_INSIGNIA , SCB_MATK | SCB_BATK | SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); + status->set_sc( SO_WATER_INSIGNIA , SC_WATER_INSIGNIA , SI_WATER_INSIGNIA , SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); + status->set_sc( SO_WIND_INSIGNIA , SC_WIND_INSIGNIA , SI_WIND_INSIGNIA , SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); + status->set_sc( SO_EARTH_INSIGNIA , SC_EARTH_INSIGNIA , SI_EARTH_INSIGNIA , SCB_MDEF|SCB_DEF|SCB_MAXHP|SCB_MAXSP|SCB_WATK | SCB_ATK_ELE | SCB_REGEN ); add_sc( SO_ELEMENTAL_SHIELD , SC_SAFETYWALL ); /** * Genetic **/ - set_sc( GN_CARTBOOST , SC_GN_CARTBOOST, SI_CARTSBOOST , SCB_SPEED ); - set_sc( GN_THORNS_TRAP , SC_THORNS_TRAP , SI_THORNTRAP , SCB_NONE ); + status->set_sc( GN_CARTBOOST , SC_GN_CARTBOOST, SI_CARTSBOOST , SCB_SPEED ); + status->set_sc( GN_THORNS_TRAP , SC_THORNS_TRAP , SI_THORNTRAP , SCB_NONE ); set_sc_with_vfx( GN_BLOOD_SUCKER , SC_BLOOD_SUCKER , SI_BLOODSUCKER , SCB_NONE ); - set_sc( GN_WALLOFTHORN , SC_STOP , SI_BLANK , SCB_NONE ); - set_sc( GN_FIRE_EXPANSION_SMOKE_POWDER, SC_FIRE_EXPANSION_SMOKE_POWDER , SI_FIRE_EXPANSION_SMOKE_POWDER, SCB_NONE ); - set_sc( GN_FIRE_EXPANSION_TEAR_GAS , SC_FIRE_EXPANSION_TEAR_GAS , SI_FIRE_EXPANSION_TEAR_GAS , SCB_NONE ); - set_sc( GN_MANDRAGORA , SC_MANDRAGORA , SI_MANDRAGORA , SCB_INT ); + status->set_sc( GN_WALLOFTHORN , SC_STOP , SI_BLANK , SCB_NONE ); + status->set_sc( GN_FIRE_EXPANSION_SMOKE_POWDER, SC_FIRE_EXPANSION_SMOKE_POWDER , SI_FIRE_EXPANSION_SMOKE_POWDER, SCB_NONE ); + status->set_sc( GN_FIRE_EXPANSION_TEAR_GAS , SC_FIRE_EXPANSION_TEAR_GAS , SI_FIRE_EXPANSION_TEAR_GAS , SCB_NONE ); + status->set_sc( GN_MANDRAGORA , SC_MANDRAGORA , SI_MANDRAGORA , SCB_INT ); // Elemental Spirit summoner's 'side' status changes. - set_sc( EL_CIRCLE_OF_FIRE , SC_CIRCLE_OF_FIRE_OPTION, SI_CIRCLE_OF_FIRE_OPTION, SCB_NONE ); - set_sc( EL_FIRE_CLOAK , SC_FIRE_CLOAK_OPTION , SI_FIRE_CLOAK_OPTION , SCB_ALL ); - set_sc( EL_WATER_SCREEN , SC_WATER_SCREEN_OPTION , SI_WATER_SCREEN_OPTION , SCB_NONE ); - set_sc( EL_WATER_DROP , SC_WATER_DROP_OPTION , SI_WATER_DROP_OPTION , SCB_ALL ); - set_sc( EL_WATER_BARRIER , SC_WATER_BARRIER , SI_WATER_BARRIER , SCB_WATK|SCB_FLEE ); - set_sc( EL_WIND_STEP , SC_WIND_STEP_OPTION , SI_WIND_STEP_OPTION , SCB_SPEED|SCB_FLEE ); - set_sc( EL_WIND_CURTAIN , SC_WIND_CURTAIN_OPTION , SI_WIND_CURTAIN_OPTION , SCB_ALL ); - set_sc( EL_ZEPHYR , SC_ZEPHYR , SI_ZEPHYR , SCB_FLEE ); - set_sc( EL_SOLID_SKIN , SC_SOLID_SKIN_OPTION , SI_SOLID_SKIN_OPTION , SCB_DEF|SCB_MAXHP ); - set_sc( EL_STONE_SHIELD , SC_STONE_SHIELD_OPTION , SI_STONE_SHIELD_OPTION , SCB_ALL ); - set_sc( EL_POWER_OF_GAIA , SC_POWER_OF_GAIA , SI_POWER_OF_GAIA , SCB_MAXHP|SCB_DEF|SCB_SPEED ); - set_sc( EL_PYROTECHNIC , SC_PYROTECHNIC_OPTION , SI_PYROTECHNIC_OPTION , SCB_WATK ); - set_sc( EL_HEATER , SC_HEATER_OPTION , SI_HEATER_OPTION , SCB_WATK ); - set_sc( EL_TROPIC , SC_TROPIC_OPTION , SI_TROPIC_OPTION , SCB_WATK ); - set_sc( EL_AQUAPLAY , SC_AQUAPLAY_OPTION , SI_AQUAPLAY_OPTION , SCB_MATK ); - set_sc( EL_COOLER , SC_COOLER_OPTION , SI_COOLER_OPTION , SCB_MATK ); - set_sc( EL_CHILLY_AIR , SC_CHILLY_AIR_OPTION , SI_CHILLY_AIR_OPTION , SCB_MATK ); - set_sc( EL_GUST , SC_GUST_OPTION , SI_GUST_OPTION , SCB_ASPD ); - set_sc( EL_BLAST , SC_BLAST_OPTION , SI_BLAST_OPTION , SCB_ASPD ); - set_sc( EL_WILD_STORM , SC_WILD_STORM_OPTION , SI_WILD_STORM_OPTION , SCB_ASPD ); - set_sc( EL_PETROLOGY , SC_PETROLOGY_OPTION , SI_PETROLOGY_OPTION , SCB_MAXHP ); - set_sc( EL_CURSED_SOIL , SC_CURSED_SOIL_OPTION , SI_CURSED_SOIL_OPTION , SCB_MAXHP ); - set_sc( EL_UPHEAVAL , SC_UPHEAVAL_OPTION , SI_UPHEAVAL_OPTION , SCB_MAXHP ); - set_sc( EL_TIDAL_WEAPON , SC_TIDAL_WEAPON_OPTION , SI_TIDAL_WEAPON_OPTION , SCB_ALL ); - set_sc( EL_ROCK_CRUSHER , SC_ROCK_CRUSHER , SI_ROCK_CRUSHER , SCB_DEF ); - set_sc( EL_ROCK_CRUSHER_ATK, SC_ROCK_CRUSHER_ATK , SI_ROCK_CRUSHER_ATK , SCB_SPEED ); + status->set_sc( EL_CIRCLE_OF_FIRE , SC_CIRCLE_OF_FIRE_OPTION, SI_CIRCLE_OF_FIRE_OPTION, SCB_NONE ); + status->set_sc( EL_FIRE_CLOAK , SC_FIRE_CLOAK_OPTION , SI_FIRE_CLOAK_OPTION , SCB_ALL ); + status->set_sc( EL_WATER_SCREEN , SC_WATER_SCREEN_OPTION , SI_WATER_SCREEN_OPTION , SCB_NONE ); + status->set_sc( EL_WATER_DROP , SC_WATER_DROP_OPTION , SI_WATER_DROP_OPTION , SCB_ALL ); + status->set_sc( EL_WATER_BARRIER , SC_WATER_BARRIER , SI_WATER_BARRIER , SCB_WATK|SCB_FLEE ); + status->set_sc( EL_WIND_STEP , SC_WIND_STEP_OPTION , SI_WIND_STEP_OPTION , SCB_SPEED|SCB_FLEE ); + status->set_sc( EL_WIND_CURTAIN , SC_WIND_CURTAIN_OPTION , SI_WIND_CURTAIN_OPTION , SCB_ALL ); + status->set_sc( EL_ZEPHYR , SC_ZEPHYR , SI_ZEPHYR , SCB_FLEE ); + status->set_sc( EL_SOLID_SKIN , SC_SOLID_SKIN_OPTION , SI_SOLID_SKIN_OPTION , SCB_DEF|SCB_MAXHP ); + status->set_sc( EL_STONE_SHIELD , SC_STONE_SHIELD_OPTION , SI_STONE_SHIELD_OPTION , SCB_ALL ); + status->set_sc( EL_POWER_OF_GAIA , SC_POWER_OF_GAIA , SI_POWER_OF_GAIA , SCB_MAXHP|SCB_DEF|SCB_SPEED ); + status->set_sc( EL_PYROTECHNIC , SC_PYROTECHNIC_OPTION , SI_PYROTECHNIC_OPTION , SCB_WATK ); + status->set_sc( EL_HEATER , SC_HEATER_OPTION , SI_HEATER_OPTION , SCB_WATK ); + status->set_sc( EL_TROPIC , SC_TROPIC_OPTION , SI_TROPIC_OPTION , SCB_WATK ); + status->set_sc( EL_AQUAPLAY , SC_AQUAPLAY_OPTION , SI_AQUAPLAY_OPTION , SCB_MATK ); + status->set_sc( EL_COOLER , SC_COOLER_OPTION , SI_COOLER_OPTION , SCB_MATK ); + status->set_sc( EL_CHILLY_AIR , SC_CHILLY_AIR_OPTION , SI_CHILLY_AIR_OPTION , SCB_MATK ); + status->set_sc( EL_GUST , SC_GUST_OPTION , SI_GUST_OPTION , SCB_ASPD ); + status->set_sc( EL_BLAST , SC_BLAST_OPTION , SI_BLAST_OPTION , SCB_ASPD ); + status->set_sc( EL_WILD_STORM , SC_WILD_STORM_OPTION , SI_WILD_STORM_OPTION , SCB_ASPD ); + status->set_sc( EL_PETROLOGY , SC_PETROLOGY_OPTION , SI_PETROLOGY_OPTION , SCB_MAXHP ); + status->set_sc( EL_CURSED_SOIL , SC_CURSED_SOIL_OPTION , SI_CURSED_SOIL_OPTION , SCB_MAXHP ); + status->set_sc( EL_UPHEAVAL , SC_UPHEAVAL_OPTION , SI_UPHEAVAL_OPTION , SCB_MAXHP ); + status->set_sc( EL_TIDAL_WEAPON , SC_TIDAL_WEAPON_OPTION , SI_TIDAL_WEAPON_OPTION , SCB_ALL ); + status->set_sc( EL_ROCK_CRUSHER , SC_ROCK_CRUSHER , SI_ROCK_CRUSHER , SCB_DEF ); + status->set_sc( EL_ROCK_CRUSHER_ATK, SC_ROCK_CRUSHER_ATK , SI_ROCK_CRUSHER_ATK , SCB_SPEED ); add_sc( KO_YAMIKUMO , SC_HIDING ); set_sc_with_vfx( KO_JYUMONJIKIRI , SC_KO_JYUMONJIKIRI , SI_KO_JYUMONJIKIRI , SCB_NONE ); add_sc( KO_MAKIBISHI , SC_STUN ); - set_sc( KO_MEIKYOUSISUI , SC_MEIKYOUSISUI , SI_MEIKYOUSISUI , SCB_NONE ); - set_sc( KO_KYOUGAKU , SC_KYOUGAKU , SI_KYOUGAKU , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); + status->set_sc( KO_MEIKYOUSISUI , SC_MEIKYOUSISUI , SI_MEIKYOUSISUI , SCB_NONE ); + status->set_sc( KO_KYOUGAKU , SC_KYOUGAKU , SI_KYOUGAKU , SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); add_sc( KO_JYUSATSU , SC_CURSE ); - set_sc( KO_ZENKAI , SC_ZENKAI , SI_ZENKAI , SCB_NONE ); - set_sc( KO_IZAYOI , SC_IZAYOI , SI_IZAYOI , SCB_MATK ); - set_sc( KG_KYOMU , SC_KYOMU , SI_KYOMU , SCB_NONE ); - set_sc( KG_KAGEMUSYA , SC_KAGEMUSYA , SI_KAGEMUSYA , SCB_NONE ); - set_sc( KG_KAGEHUMI , SC_KG_KAGEHUMI , SI_KG_KAGEHUMI , SCB_NONE ); - set_sc( OB_ZANGETSU , SC_ZANGETSU , SI_ZANGETSU , SCB_MATK|SCB_BATK ); + status->set_sc( KO_ZENKAI , SC_ZENKAI , SI_ZENKAI , SCB_NONE ); + status->set_sc( KO_IZAYOI , SC_IZAYOI , SI_IZAYOI , SCB_MATK ); + status->set_sc( KG_KYOMU , SC_KYOMU , SI_KYOMU , SCB_NONE ); + status->set_sc( KG_KAGEMUSYA , SC_KAGEMUSYA , SI_KAGEMUSYA , SCB_NONE ); + status->set_sc( KG_KAGEHUMI , SC_KG_KAGEHUMI , SI_KG_KAGEHUMI , SCB_NONE ); + status->set_sc( OB_ZANGETSU , SC_ZANGETSU , SI_ZANGETSU , SCB_MATK|SCB_BATK ); set_sc_with_vfx( OB_AKAITSUKI, SC_AKAITSUKI , SI_AKAITSUKI , SCB_NONE ); - set_sc( OB_OBOROGENSOU , SC_GENSOU , SI_GENSOU , SCB_NONE ); + status->set_sc( OB_OBOROGENSOU , SC_GENSOU , SI_GENSOU , SCB_NONE ); - set_sc( ALL_FULL_THROTTLE , SC_FULL_THROTTLE , SI_FULL_THROTTLE , SCB_SPEED|SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); + status->set_sc( ALL_FULL_THROTTLE , SC_FULL_THROTTLE , SI_FULL_THROTTLE , SCB_SPEED|SCB_STR|SCB_AGI|SCB_VIT|SCB_INT|SCB_DEX|SCB_LUK ); add_sc( ALL_REVERSEORCISH , SC_ORCISH ); - set_sc( ALL_ANGEL_PROTECT , SC_ANGEL_PROTECT , SI_ANGEL_PROTECT , SCB_REGEN ); + status->set_sc( ALL_ANGEL_PROTECT , SC_ANGEL_PROTECT , SI_ANGEL_PROTECT , SCB_REGEN ); add_sc( NPC_WIDEHEALTHFEAR , SC_FEAR ); add_sc( NPC_WIDEBODYBURNNING , SC_BURNING ); @@ -1237,7 +1238,7 @@ void initDummyData(void) } //For copying a status_data structure from b to a, without overwriting current Hp and Sp -static inline void status_cpy(struct status_data* a, const struct status_data* b) +void status_copy(struct status_data *a, const struct status_data *b) { memcpy((void*)&a->max_hp, (const void*)&b->max_hp, sizeof(struct status_data)-(sizeof(a->hp)+sizeof(a->sp))); } @@ -3160,7 +3161,7 @@ int status_calc_pc_(struct map_session_data* sd, enum e_status_calc_opt opt) { sd->left_weapon.addrace[RC_DEMON] += sc->data[SC_PHI_DEMON]->val1; } } - status_cpy(&sd->battle_status, bstatus); + status->copy(&sd->battle_status, bstatus); // ----- CLIENT-SIDE REFRESH ----- if(!sd->bl.prev) { @@ -3199,7 +3200,7 @@ int status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt opt } status->calc_misc(&md->bl, mstatus, md->db->lv); - status_cpy(&md->battle_status, mstatus); + status->copy(&md->battle_status, mstatus); return 0; } @@ -3237,7 +3238,7 @@ int status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt opt memcpy(&ed->battle_status, estatus, sizeof(struct status_data)); } else { status->calc_misc(&ed->bl, estatus, 0); - status_cpy(&ed->battle_status, estatus); + status->copy(&ed->battle_status, estatus); } return 0; @@ -3274,7 +3275,7 @@ int status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) { nstatus->luk = nd->stat_point; status->calc_misc(&nd->bl, nstatus, nd->level); - status_cpy(&nd->status, nstatus); + status->copy(&nd->status, nstatus); return 0; } @@ -3360,7 +3361,7 @@ int status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt) { status->calc_misc(&hd->bl, hstatus, hom->level); - status_cpy(&hd->battle_status, hstatus); + status->copy(&hd->battle_status, hstatus); return 1; } @@ -3540,7 +3541,7 @@ void status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, str #endif regen->rate.sp += 1; } - + if (sc->data[SC_GDSKILL_REGENERATION]) { const struct status_change_entry *sce = sc->data[SC_GDSKILL_REGENERATION]; if (!sce->val4) { @@ -3610,7 +3611,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag) { } if((!(bl->type&BL_REGEN)) && (!sc || !sc->count)) { //No difference. - status_cpy(st, bst); + status->copy(st, bst); return; } @@ -4300,10 +4301,15 @@ unsigned short status_base_atk(const struct block_list *bl, const struct status_ return cap_value(str, 0, USHRT_MAX); } -#ifndef RENEWAL -static inline unsigned short status_base_matk_min(const struct status_data *st) { return st->int_ + (st->int_ / 7)*(st->int_ / 7); } -#endif // not RENEWAL -static inline unsigned short status_base_matk_max(const struct status_data *st) { return st->int_ + (st->int_ / 5)*(st->int_ / 5); } +unsigned short status_base_matk_min(const struct status_data *st) +{ + return st->int_ + (st->int_ / 7) * (st->int_ / 7); +} + +unsigned short status_base_matk_max(const struct status_data *st) +{ + return st->int_ + (st->int_ / 5)*(st->int_ / 5); +} unsigned short status_base_matk(struct block_list *bl, const struct status_data *st, int level) { #ifdef RENEWAL @@ -4350,8 +4356,8 @@ void status_calc_misc(struct block_list *bl, struct status_data *st, int level) st->mdef2 += (int)(bl->type == BL_PC ? (st->int_ + ((float)level / 4) + ((float)(st->dex + st->vit) / 5)) : ((float)(st->int_ + level) / 4)); //(every 4 base level = +1 mdef) + (every 1 int = +1 mdef) + (every 5 dex = +1 mdef) + (every 5 vit = +1 mdef) } #else // not RENEWAL - st->matk_min = status_base_matk_min(st); - st->matk_max = status_base_matk_max(st); + st->matk_min = status->base_matk_min(st); + st->matk_max = status->base_matk_max(st); st->hit += level + st->dex; st->flee += level + st->agi; st->def2 += st->vit; @@ -4386,7 +4392,7 @@ void status_calc_misc(struct block_list *bl, struct status_data *st, int level) break; case BL_MER: #ifdef RENEWAL - st->matk_min = st->matk_max = status_base_matk_max(st); + st->matk_min = st->matk_max = status->base_matk_max(st); st->def2 = st->vit + level / 10 + st->vit / 5; st->mdef2 = level / 10 + st->int_ / 5; #endif @@ -5576,9 +5582,9 @@ unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc { int val = 0; - if( sd && sc->data[SC_HIDING] && pc->checkskill(sd,RG_TUNNELDRIVE) > 0 ) + if ( sd && sc->data[SC_HIDING] && pc->checkskill(sd,RG_TUNNELDRIVE) > 0 ) { val = 120 - 6 * pc->checkskill(sd,RG_TUNNELDRIVE); - else + } else { if( sd && sc->data[SC_CHASEWALK] && sc->data[SC_CHASEWALK]->val3 < 0 ) val = sc->data[SC_CHASEWALK]->val3; else @@ -5648,8 +5654,8 @@ unsigned short status_calc_speed(struct block_list *bl, struct status_change *sc if( sd && sd->bonus.speed_rate + sd->bonus.speed_add_rate > 0 ) // permanent item-based speedup val = max( val, sd->bonus.speed_rate + sd->bonus.speed_add_rate ); } - - speed_rate += val; + } + speed_rate += val; } //GetMoveHasteValue1() @@ -7495,8 +7501,9 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC break; case SC_NOEQUIPSHIELD: - if( val2 == 1 ) val2 = 0; //GX effect. Do not take shield off.. - else + if (val2 == 1) { + val2 = 0; //GX effect. Do not take shield off.. + } else { if (sd && !(flag&SCFLAG_LOADED)) { int i; if(sd->bonus.unstripable_equip&EQP_SHIELD) @@ -7506,8 +7513,10 @@ int status_change_start(struct block_list *src, struct block_list *bl, enum sc_t return 0; pc->unequipitem(sd, i, PCUNEQUIPITEM_RECALC|PCUNEQUIPITEM_FORCE); } - if (tick == 1) return 1; //Minimal duration: Only strip without causing the SC - break; + } + if (tick == 1) + return 1; //Minimal duration: Only strip without causing the SC + break; case SC_NOEQUIPARMOR: if (sd && !(flag&SCFLAG_LOADED)) { int i; @@ -11610,7 +11619,7 @@ int status_change_timer(int tid, int64 tick, int id, intptr_t data) { if( --(sce->val4) > 0 ) { struct block_list *src = map->id2bl(sce->val2); int damage; - if( !src || (src && (status->isdead(src) || src->m != bl->m || distance_bl(src, bl) >= 12)) ) + if (src == NULL || (status->isdead(src) || src->m != bl->m || distance_bl(src, bl) >= 12)) break; map->freeblock_lock(); damage = sce->val3; @@ -12107,8 +12116,8 @@ void status_get_matk_sub(struct block_list *bl, int flag, unsigned short *matk_m } #else // not RENEWAL - *matk_min = status_base_matk_min(st) + (sd ? sd->bonus.ematk : 0); - *matk_max = status_base_matk_max(st) + (sd ? sd->bonus.ematk : 0); + *matk_min = status->base_matk_min(st) + (sd ? sd->bonus.ematk : 0); + *matk_max = status->base_matk_max(st) + (sd ? sd->bonus.ematk : 0); #endif if ( sd && sd->matk_rate != 100 ) { @@ -12961,7 +12970,7 @@ int status_readdb_refine_libconfig(const char *filename) { struct config_t refine_db_conf; struct config_setting_t *r; char filepath[256]; - int i = 0, count = 0,type = 0; + int i = 0, count = 0; sprintf(filepath, "%s/%s", map->db_path, filename); if (!libconfig->load_file(&refine_db_conf, filepath)) @@ -12971,10 +12980,13 @@ int status_readdb_refine_libconfig(const char *filename) { while((r = libconfig->setting_get_elem(refine_db_conf.root,i++))) { char *name = config_setting_name(r); - if((type=status->readdb_refine_libconfig_sub(r, name, filename))) { - if( duplicate[type-1] ) { + int type = status->readdb_refine_libconfig_sub(r, name, filename); + if (type != 0) { + if (duplicate[type-1]) { ShowWarning("status_readdb_refine_libconfig: duplicate entry for %s in \"%s\", overwriting previous entry...\n", name, filename); - } else duplicate[type-1] = true; + } else { + duplicate[type-1] = true; + } count++; } } @@ -13224,4 +13236,10 @@ void status_defaults(void) { status->readdb_scconfig = status_readdb_scconfig; status->read_job_db = status_read_job_db; status->read_job_db_sub = status_read_job_db_sub; + status->set_sc = status_set_sc; + status->copy = status_copy; +#ifndef RENEWAL + status->base_matk_min = status_base_matk_min; +#endif // RENEWAL + status->base_matk_max = status_base_matk_max; } diff --git a/src/map/status.h b/src/map/status.h index 2b932b149..dbb507bd1 100644 --- a/src/map/status.h +++ b/src/map/status.h @@ -64,7 +64,9 @@ enum refine_type { REFINE_TYPE_WEAPON2 = 2, REFINE_TYPE_WEAPON3 = 3, REFINE_TYPE_WEAPON4 = 4, +#ifndef REFINE_TYPE_MAX REFINE_TYPE_MAX = 5 +#endif }; /** @@ -825,8 +827,9 @@ typedef enum sc_type { SC_M_LIFEPOTION, SC_G_LIFEPOTION, // 640 SC_MYSTICPOWDER, - +#ifndef SC_MAX SC_MAX, //Automatically updated max, used in for's to check we are within bounds. +#endif } sc_type; /// Official status change ids, used to display status icons in the client. @@ -1792,8 +1795,9 @@ enum si_type { //SI_EP16_2_BUFF_SS = 963, //SI_EP16_2_BUFF_SC = 964, //SI_EP16_2_BUFF_AC = 965, - +#ifndef SI_MAX SI_MAX, +#endif }; // JOINTBEAT stackable ailments @@ -2313,6 +2317,10 @@ struct status_interface { bool (*readdb_scconfig) (char *fields[], int columns, int current); void (*read_job_db) (void); void (*read_job_db_sub) (int idx, const char *name, struct config_setting_t *jdb); + void (*set_sc) (uint16 skill_id, sc_type sc, int icon, unsigned int flag); + void (*copy) (struct status_data *a, const struct status_data *b); + unsigned short (*base_matk_min) (const struct status_data *st); + unsigned short (*base_matk_max) (const struct status_data *st); }; #ifdef HERCULES_CORE diff --git a/src/map/unit.c b/src/map/unit.c index 9a698b77e..ac1e3e9b5 100644 --- a/src/map/unit.c +++ b/src/map/unit.c @@ -1220,6 +1220,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, ui ud = unit->bl2ud(src); if(ud == NULL) return 0; + sc = status->get_sc(src); if (sc && !sc->count) sc = NULL; //Unneeded @@ -2289,11 +2290,18 @@ int unit_skillcastcancel(struct block_list *bl,int type) // unit_data initialization process void unit_dataset(struct block_list *bl) { - struct unit_data *ud; - nullpo_retv(ud = unit->bl2ud(bl)); + struct unit_data *ud = unit->bl2ud(bl); + nullpo_retv(ud); + + unit->init_ud(ud); + ud->bl = bl; +} + +void unit_init_ud(struct unit_data *ud) +{ + nullpo_retv(ud); - memset( ud, 0, sizeof( struct unit_data) ); - ud->bl = bl; + memset (ud, 0, sizeof(struct unit_data)); ud->walktimer = INVALID_TIMER; ud->skilltimer = INVALID_TIMER; ud->attacktimer = INVALID_TIMER; @@ -2433,7 +2441,7 @@ int unit_remove_map(struct block_list *bl, clr_type clrtype, const char* file, i status_change_end(d_bl,SC__SHADOWFORM,INVALID_TIMER); } //Leave/reject all invitations. - if(sd->chatID) + if (sd->chat_id != 0) chat->leave(sd, false); if(sd->trade_partner) trade->cancel(sd); @@ -2895,6 +2903,7 @@ void unit_defaults(void) { /* */ unit->bl2ud = unit_bl2ud; unit->bl2ud2 = unit_bl2ud2; + unit->init_ud = unit_init_ud; unit->attack_timer = unit_attack_timer; unit->walktoxy_timer = unit_walktoxy_timer; unit->walktoxy_sub = unit_walktoxy_sub; diff --git a/src/map/unit.h b/src/map/unit.h index 0279d73c1..8c4c34696 100644 --- a/src/map/unit.h +++ b/src/map/unit.h @@ -105,6 +105,7 @@ struct unit_interface { /* */ struct unit_data* (*bl2ud) (struct block_list *bl); struct unit_data* (*bl2ud2) (struct block_list *bl); + void (*init_ud) (struct unit_data *ud); int (*attack_timer) (int tid, int64 tick, int id, intptr_t data); int (*walktoxy_timer) (int tid, int64 tick, int id, intptr_t data); int (*walktoxy_sub) (struct block_list *bl); diff --git a/src/map/vending.c b/src/map/vending.c index d9001f6f5..3ae1017f8 100644 --- a/src/map/vending.c +++ b/src/map/vending.c @@ -199,7 +199,7 @@ void vending_purchasereq(struct map_session_data* sd, int aid, unsigned int uid, if( battle_config.buyer_name ) { char temp[256]; sprintf(temp, msg_sd(vsd,265), sd->status.name); - clif_disp_onlyself(vsd,temp,strlen(temp)); + clif_disp_onlyself(vsd, temp); } } @@ -276,7 +276,7 @@ void vending_openvending(struct map_session_data* sd, const char* message, const || pc->cartitem_amount(sd, index, amount) < 0 // invalid item or insufficient quantity //NOTE: official server does not do any of the following checks! || !sd->status.cart[index].identify // unidentified item - || sd->status.cart[index].attribute == 1 // broken item + || (sd->status.cart[index].attribute & ATTR_BROKEN) != 0 // broken item || sd->status.cart[index].expire_time // It should not be in the cart but just in case || (sd->status.cart[index].bound && !pc_can_give_bound_items(sd)) // can't trade bound items w/o permission || !itemdb_cantrade(&sd->status.cart[index], pc_get_group_level(sd), pc_get_group_level(sd)) ) // untradeable item diff --git a/src/plugins/HPMHooking.c b/src/plugins/HPMHooking.c index 6530035b9..4fb7911c2 100644 --- a/src/plugins/HPMHooking.c +++ b/src/plugins/HPMHooking.c @@ -17,6 +17,9 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "HPMHooking.h" + #include "common/hercules.h" #include "common/db.h" #include "common/memmgr.h" diff --git a/src/plugins/HPMHooking.h b/src/plugins/HPMHooking.h new file mode 100644 index 000000000..44970863c --- /dev/null +++ b/src/plugins/HPMHooking.h @@ -0,0 +1,65 @@ +/** + * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules + * + * Copyright (C) 2016 Hercules Dev Team + * + * Hercules is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +#ifndef PLUGINS_HPMHOOKING_H +#define PLUGINS_HPMHOOKING_H + +#include "common/hercules.h" + +enum HPluginHookType { + HOOK_TYPE_PRE, + HOOK_TYPE_POST, +}; + +struct HPMHooking_interface { + bool (*AddHook) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID); + void (*HookStop) (const char *func, unsigned int pID); + bool (*HookStopped) (void); +}; + +#ifdef HERCULES_CORE +struct HPMHooking_core_interface { + bool enabled; + bool force_return; + bool (*addhook_sub) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID); + const char *(*Hooked)(bool *fr); +}; +#else // ! HERCULES_CORE +HPExport struct HPMHooking_interface HPMHooking_s; + +#include "HPMHooking/HPMHooking.Defs.inc" + +#define addHookPre(ifname, funcname, hook) ( \ + (void)((HPMHOOK_pre_ ## ifname ## _ ## funcname)0 == (hook)), \ + HPMi->hooking->AddHook(HOOK_TYPE_PRE, #ifname "->" #funcname, (hook), HPMi->pid) \ + ) + +#define addHookPost(ifname, funcname, hook) ( \ + (void)((HPMHOOK_post_ ## ifname ## _ ## funcname)0 == (hook)), \ + HPMi->hooking->AddHook(HOOK_TYPE_POST, #ifname "->" #funcname, (hook), HPMi->pid) \ + ) + +/* need better names ;/ */ +/* will not run the original function after pre-hook processing is complete (other hooks will run) */ +#define hookStop() (HPMi->hooking->HookStop(__func__,HPMi->pid)) +#define hookStopped() (HPMi->hooking->HookStopped()) + +#endif // ! HERCULES_CORE + +#endif // PLUGINS_HPMHOOKING_H diff --git a/src/plugins/HPMHooking/HPMHooking.Defs.inc b/src/plugins/HPMHooking/HPMHooking.Defs.inc new file mode 100644 index 000000000..07782571d --- /dev/null +++ b/src/plugins/HPMHooking/HPMHooking.Defs.inc @@ -0,0 +1,7147 @@ +/** + * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules + * + * Copyright (C) 2013-2016 Hercules Dev Team + * + * Hercules is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +/* + * NOTE: This file was auto-generated and should never be manually edited, + * as it will get overwritten. + */ + +/* GENERATED FILE DO NOT EDIT */ + +#ifdef COMMON_UTILS_H /* HCache */ +typedef void (*HPMHOOK_pre_HCache_init) (void); +typedef void (*HPMHOOK_post_HCache_init) (void); +typedef bool (*HPMHOOK_pre_HCache_check) (const char **file); +typedef bool (*HPMHOOK_post_HCache_check) (bool retVal___, const char *file); +typedef FILE* (*HPMHOOK_pre_HCache_open) (const char **file, const char **opt); +typedef FILE* (*HPMHOOK_post_HCache_open) (FILE* retVal___, const char *file, const char *opt); +#endif // COMMON_UTILS_H +#ifdef MAP_ATCOMMAND_H /* atcommand */ +typedef void (*HPMHOOK_pre_atcommand_init) (bool *minimal); +typedef void (*HPMHOOK_post_atcommand_init) (bool minimal); +typedef void (*HPMHOOK_pre_atcommand_final) (void); +typedef void (*HPMHOOK_post_atcommand_final) (void); +typedef bool (*HPMHOOK_pre_atcommand_exec) (const int *fd, struct map_session_data **sd, const char **message, bool *player_invoked); +typedef bool (*HPMHOOK_post_atcommand_exec) (bool retVal___, const int fd, struct map_session_data *sd, const char *message, bool player_invoked); +typedef bool (*HPMHOOK_pre_atcommand_create) (char **name, AtCommandFunc *func); +typedef bool (*HPMHOOK_post_atcommand_create) (bool retVal___, char *name, AtCommandFunc func); +typedef bool (*HPMHOOK_pre_atcommand_can_use) (struct map_session_data **sd, const char **command); +typedef bool (*HPMHOOK_post_atcommand_can_use) (bool retVal___, struct map_session_data *sd, const char *command); +typedef bool (*HPMHOOK_pre_atcommand_can_use2) (struct map_session_data **sd, const char **command, AtCommandType *type); +typedef bool (*HPMHOOK_post_atcommand_can_use2) (bool retVal___, struct map_session_data *sd, const char *command, AtCommandType type); +typedef void (*HPMHOOK_pre_atcommand_load_groups) (GroupSettings ***groups, struct config_setting_t ***commands_, size_t *sz); +typedef void (*HPMHOOK_post_atcommand_load_groups) (GroupSettings **groups, struct config_setting_t **commands_, size_t sz); +typedef AtCommandInfo* (*HPMHOOK_pre_atcommand_exists) (const char **name); +typedef AtCommandInfo* (*HPMHOOK_post_atcommand_exists) (AtCommandInfo* retVal___, const char *name); +typedef bool (*HPMHOOK_pre_atcommand_msg_read) (const char **cfg_name, bool *allow_override); +typedef bool (*HPMHOOK_post_atcommand_msg_read) (bool retVal___, const char *cfg_name, bool allow_override); +typedef void (*HPMHOOK_pre_atcommand_final_msg) (void); +typedef void (*HPMHOOK_post_atcommand_final_msg) (void); +typedef struct atcmd_binding_data* (*HPMHOOK_pre_atcommand_get_bind_byname) (const char **name); +typedef struct atcmd_binding_data* (*HPMHOOK_post_atcommand_get_bind_byname) (struct atcmd_binding_data* retVal___, const char *name); +typedef AtCommandInfo* (*HPMHOOK_pre_atcommand_get_info_byname) (const char **name); +typedef AtCommandInfo* (*HPMHOOK_post_atcommand_get_info_byname) (AtCommandInfo* retVal___, const char *name); +typedef const char* (*HPMHOOK_pre_atcommand_check_alias) (const char **aliasname); +typedef const char* (*HPMHOOK_post_atcommand_check_alias) (const char* retVal___, const char *aliasname); +typedef void (*HPMHOOK_pre_atcommand_get_suggestions) (struct map_session_data **sd, const char **name, bool *is_atcmd_cmd); +typedef void (*HPMHOOK_post_atcommand_get_suggestions) (struct map_session_data *sd, const char *name, bool is_atcmd_cmd); +typedef void (*HPMHOOK_pre_atcommand_config_read) (const char **config_filename); +typedef void (*HPMHOOK_post_atcommand_config_read) (const char *config_filename); +typedef int (*HPMHOOK_pre_atcommand_stopattack) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_stopattack) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_atcommand_pvpoff_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_pvpoff_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_atcommand_pvpon_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_pvpon_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_atcommand_atkillmonster_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_atkillmonster_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_atcommand_raise_sub) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_atcommand_raise_sub) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_atcommand_get_jail_time) (int *jailtime, int **year, int **month, int **day, int **hour, int **minute); +typedef void (*HPMHOOK_post_atcommand_get_jail_time) (int jailtime, int *year, int *month, int *day, int *hour, int *minute); +typedef int (*HPMHOOK_pre_atcommand_cleanfloor_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_cleanfloor_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_atcommand_mutearea_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_atcommand_mutearea_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_atcommand_getring) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_atcommand_getring) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_atcommand_channel_help) (int *fd, const char **command, bool *can_create); +typedef void (*HPMHOOK_post_atcommand_channel_help) (int fd, const char *command, bool can_create); +typedef void (*HPMHOOK_pre_atcommand_commands_sub) (struct map_session_data **sd, const int *fd, AtCommandType *type); +typedef void (*HPMHOOK_post_atcommand_commands_sub) (struct map_session_data *sd, const int fd, AtCommandType type); +typedef void (*HPMHOOK_pre_atcommand_cmd_db_clear) (void); +typedef void (*HPMHOOK_post_atcommand_cmd_db_clear) (void); +typedef int (*HPMHOOK_pre_atcommand_cmd_db_clear_sub) (union DBKey *key, struct DBData **data, va_list args); +typedef int (*HPMHOOK_post_atcommand_cmd_db_clear_sub) (int retVal___, union DBKey key, struct DBData *data, va_list args); +typedef void (*HPMHOOK_pre_atcommand_doload) (void); +typedef void (*HPMHOOK_post_atcommand_doload) (void); +typedef void (*HPMHOOK_pre_atcommand_base_commands) (void); +typedef void (*HPMHOOK_post_atcommand_base_commands) (void); +typedef bool (*HPMHOOK_pre_atcommand_add) (char **name, AtCommandFunc *func, bool *replace); +typedef bool (*HPMHOOK_post_atcommand_add) (bool retVal___, char *name, AtCommandFunc func, bool replace); +typedef const char* (*HPMHOOK_pre_atcommand_msg) (int *msg_number); +typedef const char* (*HPMHOOK_post_atcommand_msg) (const char* retVal___, int msg_number); +typedef void (*HPMHOOK_pre_atcommand_expand_message_table) (void); +typedef void (*HPMHOOK_post_atcommand_expand_message_table) (void); +typedef const char* (*HPMHOOK_pre_atcommand_msgfd) (int *fd, int *msg_number); +typedef const char* (*HPMHOOK_post_atcommand_msgfd) (const char* retVal___, int fd, int msg_number); +typedef const char* (*HPMHOOK_pre_atcommand_msgsd) (struct map_session_data **sd, int *msg_number); +typedef const char* (*HPMHOOK_post_atcommand_msgsd) (const char* retVal___, struct map_session_data *sd, int msg_number); +#endif // MAP_ATCOMMAND_H +#ifdef MAP_BATTLE_H /* battle */ +typedef void (*HPMHOOK_pre_battle_init) (bool *minimal); +typedef void (*HPMHOOK_post_battle_init) (bool minimal); +typedef void (*HPMHOOK_pre_battle_final) (void); +typedef void (*HPMHOOK_post_battle_final) (void); +typedef struct Damage (*HPMHOOK_pre_battle_calc_attack) (int *attack_type, struct block_list **bl, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *count); +typedef struct Damage (*HPMHOOK_post_battle_calc_attack) (struct Damage retVal___, int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count); +typedef int64 (*HPMHOOK_pre_battle_calc_damage) (struct block_list **src, struct block_list **bl, struct Damage **d, int64 *damage, uint16 *skill_id, uint16 *skill_lv); +typedef int64 (*HPMHOOK_post_battle_calc_damage) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv); +typedef int64 (*HPMHOOK_pre_battle_calc_gvg_damage) (struct block_list **src, struct block_list **bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_gvg_damage) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); +typedef int64 (*HPMHOOK_pre_battle_calc_bg_damage) (struct block_list **src, struct block_list **bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_bg_damage) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); +typedef enum damage_lv (*HPMHOOK_pre_battle_weapon_attack) (struct block_list **bl, struct block_list **target, int64 *tick, int *flag); +typedef enum damage_lv (*HPMHOOK_post_battle_weapon_attack) (enum damage_lv retVal___, struct block_list *bl, struct block_list *target, int64 tick, int flag); +typedef bool (*HPMHOOK_pre_battle_check_arrows) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_battle_check_arrows) (bool retVal___, struct map_session_data *sd); +typedef struct Damage (*HPMHOOK_pre_battle_calc_weapon_attack) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *wflag); +typedef struct Damage (*HPMHOOK_post_battle_calc_weapon_attack) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag); +typedef int (*HPMHOOK_pre_battle_delay_damage) (int64 *tick, int *amotion, struct block_list **src, struct block_list **target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects); +typedef int (*HPMHOOK_post_battle_delay_damage) (int retVal___, int64 tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int64 damage, enum damage_lv dmg_lv, int ddelay, bool additional_effects); +typedef void (*HPMHOOK_pre_battle_drain) (struct map_session_data **sd, struct block_list **tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss); +typedef void (*HPMHOOK_post_battle_drain) (struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss); +typedef void (*HPMHOOK_pre_battle_reflect_damage) (struct block_list **target, struct block_list **src, struct Damage **wd, uint16 *skill_id); +typedef void (*HPMHOOK_post_battle_reflect_damage) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id); +typedef int (*HPMHOOK_pre_battle_attr_ratio) (int *atk_elem, int *def_type, int *def_lv); +typedef int (*HPMHOOK_post_battle_attr_ratio) (int retVal___, int atk_elem, int def_type, int def_lv); +typedef int64 (*HPMHOOK_pre_battle_attr_fix) (struct block_list **src, struct block_list **target, int64 *damage, int *atk_elem, int *def_type, int *def_lv); +typedef int64 (*HPMHOOK_post_battle_attr_fix) (int64 retVal___, struct block_list *src, struct block_list *target, int64 damage, int atk_elem, int def_type, int def_lv); +typedef int64 (*HPMHOOK_pre_battle_calc_cardfix) (int *attack_type, struct block_list **src, struct block_list **target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_cardfix) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int64 damage, int left, int flag); +typedef int64 (*HPMHOOK_pre_battle_calc_cardfix2) (struct block_list **src, struct block_list **bl, int64 *damage, int *s_ele, int *nk, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_cardfix2) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int s_ele, int nk, int flag); +typedef int64 (*HPMHOOK_pre_battle_calc_elefix) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_elefix) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int nk, int n_ele, int s_ele, int s_ele_, bool left, int flag); +typedef int64 (*HPMHOOK_pre_battle_calc_masteryfix) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); +typedef int64 (*HPMHOOK_post_battle_calc_masteryfix) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int div, bool left, bool weapon); +typedef int (*HPMHOOK_pre_battle_calc_chorusbonus) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_battle_calc_chorusbonus) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_battle_calc_skillratio) (int *attack_type, struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); +typedef int (*HPMHOOK_post_battle_calc_skillratio) (int retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag); +typedef int64 (*HPMHOOK_pre_battle_calc_sizefix) (struct map_session_data **sd, int64 *damage, int *type, int *size, bool *ignore); +typedef int64 (*HPMHOOK_post_battle_calc_sizefix) (int64 retVal___, struct map_session_data *sd, int64 damage, int type, int size, bool ignore); +typedef int64 (*HPMHOOK_pre_battle_calc_weapon_damage) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk **watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2); +typedef int64 (*HPMHOOK_post_battle_calc_weapon_damage) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2); +typedef int64 (*HPMHOOK_pre_battle_calc_defense) (int *attack_type, struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef); +typedef int64 (*HPMHOOK_post_battle_calc_defense) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef); +typedef struct block_list* (*HPMHOOK_pre_battle_get_master) (struct block_list **src); +typedef struct block_list* (*HPMHOOK_post_battle_get_master) (struct block_list* retVal___, struct block_list *src); +typedef struct block_list* (*HPMHOOK_pre_battle_get_targeted) (struct block_list **target); +typedef struct block_list* (*HPMHOOK_post_battle_get_targeted) (struct block_list* retVal___, struct block_list *target); +typedef struct block_list* (*HPMHOOK_pre_battle_get_enemy) (struct block_list **target, int *type, int *range); +typedef struct block_list* (*HPMHOOK_post_battle_get_enemy) (struct block_list* retVal___, struct block_list *target, int type, int range); +typedef int (*HPMHOOK_pre_battle_get_target) (struct block_list **bl); +typedef int (*HPMHOOK_post_battle_get_target) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_battle_get_current_skill) (struct block_list **bl); +typedef int (*HPMHOOK_post_battle_get_current_skill) (int retVal___, struct block_list *bl); +typedef bool (*HPMHOOK_pre_battle_check_undead) (int *race, int *element); +typedef bool (*HPMHOOK_post_battle_check_undead) (bool retVal___, int race, int element); +typedef int (*HPMHOOK_pre_battle_check_target) (struct block_list **src, struct block_list **target, int *flag); +typedef int (*HPMHOOK_post_battle_check_target) (int retVal___, struct block_list *src, struct block_list *target, int flag); +typedef bool (*HPMHOOK_pre_battle_check_range) (struct block_list **src, struct block_list **bl, int *range); +typedef bool (*HPMHOOK_post_battle_check_range) (bool retVal___, struct block_list *src, struct block_list *bl, int range); +typedef void (*HPMHOOK_pre_battle_consume_ammo) (struct map_session_data **sd, int *skill_id, int *lv); +typedef void (*HPMHOOK_post_battle_consume_ammo) (struct map_session_data *sd, int skill_id, int lv); +typedef int (*HPMHOOK_pre_battle_get_targeted_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_battle_get_targeted_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_battle_get_enemy_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_battle_get_enemy_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_battle_get_enemy_area_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_battle_get_enemy_area_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_battle_delay_damage_sub) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_battle_delay_damage_sub) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_battle_blewcount_bonus) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_battle_blewcount_bonus) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_battle_range_type) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_battle_range_type) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv); +typedef int64 (*HPMHOOK_pre_battle_calc_base_damage) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2); +typedef int64 (*HPMHOOK_post_battle_calc_base_damage) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2); +typedef int64 (*HPMHOOK_pre_battle_calc_base_damage2) (struct status_data **st, struct weapon_atk **wa, struct status_change **sc, unsigned short *t_size, struct map_session_data **sd, int *flag); +typedef int64 (*HPMHOOK_post_battle_calc_base_damage2) (int64 retVal___, struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag); +typedef struct Damage (*HPMHOOK_pre_battle_calc_misc_attack) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *mflag); +typedef struct Damage (*HPMHOOK_post_battle_calc_misc_attack) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag); +typedef struct Damage (*HPMHOOK_pre_battle_calc_magic_attack) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *mflag); +typedef struct Damage (*HPMHOOK_post_battle_calc_magic_attack) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag); +typedef int (*HPMHOOK_pre_battle_adjust_skill_damage) (int *m, unsigned short *skill_id); +typedef int (*HPMHOOK_post_battle_adjust_skill_damage) (int retVal___, int m, unsigned short skill_id); +typedef int64 (*HPMHOOK_pre_battle_add_mastery) (struct map_session_data **sd, struct block_list **target, int64 *dmg, int *type); +typedef int64 (*HPMHOOK_post_battle_add_mastery) (int64 retVal___, struct map_session_data *sd, struct block_list *target, int64 dmg, int type); +typedef int (*HPMHOOK_pre_battle_calc_drain) (int64 *damage, int *rate, int *per); +typedef int (*HPMHOOK_post_battle_calc_drain) (int retVal___, int64 damage, int rate, int per); +typedef int (*HPMHOOK_pre_battle_config_read) (const char **cfgName); +typedef int (*HPMHOOK_post_battle_config_read) (int retVal___, const char *cfgName); +typedef void (*HPMHOOK_pre_battle_config_set_defaults) (void); +typedef void (*HPMHOOK_post_battle_config_set_defaults) (void); +typedef int (*HPMHOOK_pre_battle_config_set_value) (const char **w1, const char **w2); +typedef int (*HPMHOOK_post_battle_config_set_value) (int retVal___, const char *w1, const char *w2); +typedef bool (*HPMHOOK_pre_battle_config_get_value) (const char **w1, int **value); +typedef bool (*HPMHOOK_post_battle_config_get_value) (bool retVal___, const char *w1, int *value); +typedef void (*HPMHOOK_pre_battle_config_adjust) (void); +typedef void (*HPMHOOK_post_battle_config_adjust) (void); +typedef struct block_list* (*HPMHOOK_pre_battle_get_enemy_area) (struct block_list **src, int *x, int *y, int *range, int *type, int *ignore_id); +typedef struct block_list* (*HPMHOOK_post_battle_get_enemy_area) (struct block_list* retVal___, struct block_list *src, int x, int y, int range, int type, int ignore_id); +typedef int (*HPMHOOK_pre_battle_damage_area) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_battle_damage_area) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_battle_calc_masteryfix_unknown) (struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int64 **damage, int **div, bool **left, bool **weapon); +typedef void (*HPMHOOK_post_battle_calc_masteryfix_unknown) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); +typedef void (*HPMHOOK_pre_battle_calc_skillratio_magic_unknown) (int **attack_type, struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **skillratio, int **flag); +typedef void (*HPMHOOK_post_battle_calc_skillratio_magic_unknown) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); +typedef void (*HPMHOOK_pre_battle_calc_skillratio_weapon_unknown) (int **attack_type, struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **skillratio, int **flag); +typedef void (*HPMHOOK_post_battle_calc_skillratio_weapon_unknown) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); +typedef void (*HPMHOOK_pre_battle_calc_misc_attack_unknown) (struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **mflag, struct Damage **md); +typedef void (*HPMHOOK_post_battle_calc_misc_attack_unknown) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md); +#endif // MAP_BATTLE_H +#ifdef MAP_BATTLEGROUND_H /* bg */ +typedef void (*HPMHOOK_pre_bg_init) (bool *minimal); +typedef void (*HPMHOOK_post_bg_init) (bool minimal); +typedef void (*HPMHOOK_pre_bg_final) (void); +typedef void (*HPMHOOK_post_bg_final) (void); +typedef struct bg_arena* (*HPMHOOK_pre_bg_name2arena) (const char **name); +typedef struct bg_arena* (*HPMHOOK_post_bg_name2arena) (struct bg_arena* retVal___, const char *name); +typedef void (*HPMHOOK_pre_bg_queue_add) (struct map_session_data **sd, struct bg_arena **arena, enum bg_queue_types *type); +typedef void (*HPMHOOK_post_bg_queue_add) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type); +typedef enum BATTLEGROUNDS_QUEUE_ACK (*HPMHOOK_pre_bg_can_queue) (struct map_session_data **sd, struct bg_arena **arena, enum bg_queue_types *type); +typedef enum BATTLEGROUNDS_QUEUE_ACK (*HPMHOOK_post_bg_can_queue) (enum BATTLEGROUNDS_QUEUE_ACK retVal___, struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type); +typedef int (*HPMHOOK_pre_bg_id2pos) (int *queue_id, int *account_id); +typedef int (*HPMHOOK_post_bg_id2pos) (int retVal___, int queue_id, int account_id); +typedef void (*HPMHOOK_pre_bg_queue_pc_cleanup) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_bg_queue_pc_cleanup) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_bg_begin) (struct bg_arena **arena); +typedef void (*HPMHOOK_post_bg_begin) (struct bg_arena *arena); +typedef int (*HPMHOOK_pre_bg_begin_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_bg_begin_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_bg_queue_pregame) (struct bg_arena **arena); +typedef void (*HPMHOOK_post_bg_queue_pregame) (struct bg_arena *arena); +typedef int (*HPMHOOK_pre_bg_fillup_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_bg_fillup_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_bg_queue_ready_ack) (struct bg_arena **arena, struct map_session_data **sd, bool *response); +typedef void (*HPMHOOK_post_bg_queue_ready_ack) (struct bg_arena *arena, struct map_session_data *sd, bool response); +typedef void (*HPMHOOK_pre_bg_match_over) (struct bg_arena **arena, bool *canceled); +typedef void (*HPMHOOK_post_bg_match_over) (struct bg_arena *arena, bool canceled); +typedef void (*HPMHOOK_pre_bg_queue_check) (struct bg_arena **arena); +typedef void (*HPMHOOK_post_bg_queue_check) (struct bg_arena *arena); +typedef struct battleground_data* (*HPMHOOK_pre_bg_team_search) (int *bg_id); +typedef struct battleground_data* (*HPMHOOK_post_bg_team_search) (struct battleground_data* retVal___, int bg_id); +typedef struct map_session_data* (*HPMHOOK_pre_bg_getavailablesd) (struct battleground_data **bgd); +typedef struct map_session_data* (*HPMHOOK_post_bg_getavailablesd) (struct map_session_data* retVal___, struct battleground_data *bgd); +typedef bool (*HPMHOOK_pre_bg_team_delete) (int *bg_id); +typedef bool (*HPMHOOK_post_bg_team_delete) (bool retVal___, int bg_id); +typedef bool (*HPMHOOK_pre_bg_team_warp) (int *bg_id, unsigned short *map_index, short *x, short *y); +typedef bool (*HPMHOOK_post_bg_team_warp) (bool retVal___, int bg_id, unsigned short map_index, short x, short y); +typedef void (*HPMHOOK_pre_bg_send_dot_remove) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_bg_send_dot_remove) (struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_bg_team_join) (int *bg_id, struct map_session_data **sd); +typedef bool (*HPMHOOK_post_bg_team_join) (bool retVal___, int bg_id, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_bg_team_leave) (struct map_session_data **sd, enum bg_team_leave_type *flag); +typedef int (*HPMHOOK_post_bg_team_leave) (int retVal___, struct map_session_data *sd, enum bg_team_leave_type flag); +typedef bool (*HPMHOOK_pre_bg_member_respawn) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_bg_member_respawn) (bool retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_bg_create) (unsigned short *map_index, short *rx, short *ry, const char **ev, const char **dev); +typedef int (*HPMHOOK_post_bg_create) (int retVal___, unsigned short map_index, short rx, short ry, const char *ev, const char *dev); +typedef int (*HPMHOOK_pre_bg_team_get_id) (struct block_list **bl); +typedef int (*HPMHOOK_post_bg_team_get_id) (int retVal___, struct block_list *bl); +typedef bool (*HPMHOOK_pre_bg_send_message) (struct map_session_data **sd, const char **mes); +typedef bool (*HPMHOOK_post_bg_send_message) (bool retVal___, struct map_session_data *sd, const char *mes); +typedef int (*HPMHOOK_pre_bg_send_xy_timer_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_bg_send_xy_timer_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_bg_send_xy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_bg_send_xy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_bg_afk_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_bg_afk_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_bg_team_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_bg_team_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef enum bg_queue_types (*HPMHOOK_pre_bg_str2teamtype) (const char **str); +typedef enum bg_queue_types (*HPMHOOK_post_bg_str2teamtype) (enum bg_queue_types retVal___, const char *str); +typedef void (*HPMHOOK_pre_bg_config_read) (void); +typedef void (*HPMHOOK_post_bg_config_read) (void); +#endif // MAP_BATTLEGROUND_H +#ifdef MAP_BUYINGSTORE_H /* buyingstore */ +typedef bool (*HPMHOOK_pre_buyingstore_setup) (struct map_session_data **sd, unsigned char *slots); +typedef bool (*HPMHOOK_post_buyingstore_setup) (bool retVal___, struct map_session_data *sd, unsigned char slots); +typedef void (*HPMHOOK_pre_buyingstore_create) (struct map_session_data **sd, int *zenylimit, unsigned char *result, const char **storename, const uint8 **itemlist, unsigned int *count); +typedef void (*HPMHOOK_post_buyingstore_create) (struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count); +typedef void (*HPMHOOK_pre_buyingstore_close) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_buyingstore_close) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_buyingstore_open) (struct map_session_data **sd, int *account_id); +typedef void (*HPMHOOK_post_buyingstore_open) (struct map_session_data *sd, int account_id); +typedef void (*HPMHOOK_pre_buyingstore_trade) (struct map_session_data **sd, int *account_id, unsigned int *buyer_id, const uint8 **itemlist, unsigned int *count); +typedef void (*HPMHOOK_post_buyingstore_trade) (struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count); +typedef bool (*HPMHOOK_pre_buyingstore_search) (struct map_session_data **sd, unsigned short *nameid); +typedef bool (*HPMHOOK_post_buyingstore_search) (bool retVal___, struct map_session_data *sd, unsigned short nameid); +typedef bool (*HPMHOOK_pre_buyingstore_searchall) (struct map_session_data **sd, const struct s_search_store_search **s); +typedef bool (*HPMHOOK_post_buyingstore_searchall) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s); +typedef unsigned int (*HPMHOOK_pre_buyingstore_getuid) (void); +typedef unsigned int (*HPMHOOK_post_buyingstore_getuid) (unsigned int retVal___); +#endif // MAP_BUYINGSTORE_H +#ifdef MAP_CHANNEL_H /* channel */ +typedef int (*HPMHOOK_pre_channel_init) (bool *minimal); +typedef int (*HPMHOOK_post_channel_init) (int retVal___, bool minimal); +typedef void (*HPMHOOK_pre_channel_final) (void); +typedef void (*HPMHOOK_post_channel_final) (void); +typedef struct channel_data* (*HPMHOOK_pre_channel_search) (const char **name, struct map_session_data **sd); +typedef struct channel_data* (*HPMHOOK_post_channel_search) (struct channel_data* retVal___, const char *name, struct map_session_data *sd); +typedef struct channel_data* (*HPMHOOK_pre_channel_create) (enum channel_types *type, const char **name, unsigned char *color); +typedef struct channel_data* (*HPMHOOK_post_channel_create) (struct channel_data* retVal___, enum channel_types type, const char *name, unsigned char color); +typedef void (*HPMHOOK_pre_channel_delete) (struct channel_data **chan); +typedef void (*HPMHOOK_post_channel_delete) (struct channel_data *chan); +typedef void (*HPMHOOK_pre_channel_set_password) (struct channel_data **chan, const char **password); +typedef void (*HPMHOOK_post_channel_set_password) (struct channel_data *chan, const char *password); +typedef enum channel_operation_status (*HPMHOOK_pre_channel_ban) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd); +typedef enum channel_operation_status (*HPMHOOK_post_channel_ban) (enum channel_operation_status retVal___, struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd); +typedef enum channel_operation_status (*HPMHOOK_pre_channel_unban) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd); +typedef enum channel_operation_status (*HPMHOOK_post_channel_unban) (enum channel_operation_status retVal___, struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_channel_set_options) (struct channel_data **chan, unsigned int *options); +typedef void (*HPMHOOK_post_channel_set_options) (struct channel_data *chan, unsigned int options); +typedef void (*HPMHOOK_pre_channel_send) (struct channel_data **chan, struct map_session_data **sd, const char **msg); +typedef void (*HPMHOOK_post_channel_send) (struct channel_data *chan, struct map_session_data *sd, const char *msg); +typedef void (*HPMHOOK_pre_channel_join_sub) (struct channel_data **chan, struct map_session_data **sd, bool *stealth); +typedef void (*HPMHOOK_post_channel_join_sub) (struct channel_data *chan, struct map_session_data *sd, bool stealth); +typedef enum channel_operation_status (*HPMHOOK_pre_channel_join) (struct channel_data **chan, struct map_session_data **sd, const char **password, bool *silent); +typedef enum channel_operation_status (*HPMHOOK_post_channel_join) (enum channel_operation_status retVal___, struct channel_data *chan, struct map_session_data *sd, const char *password, bool silent); +typedef void (*HPMHOOK_pre_channel_leave) (struct channel_data **chan, struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_leave) (struct channel_data *chan, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_leave_sub) (struct channel_data **chan, struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_leave_sub) (struct channel_data *chan, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_quit) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_quit) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_map_join) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_map_join) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_guild_join_alliance) (const struct guild **g_source, const struct guild **g_ally); +typedef void (*HPMHOOK_post_channel_guild_join_alliance) (const struct guild *g_source, const struct guild *g_ally); +typedef void (*HPMHOOK_pre_channel_guild_leave_alliance) (const struct guild **g_source, const struct guild **g_ally); +typedef void (*HPMHOOK_post_channel_guild_leave_alliance) (const struct guild *g_source, const struct guild *g_ally); +typedef void (*HPMHOOK_pre_channel_quit_guild) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_quit_guild) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_irc_join) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_channel_irc_join) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_channel_config_read) (void); +typedef void (*HPMHOOK_post_channel_config_read) (void); +#endif // MAP_CHANNEL_H +#ifdef CHAR_CHAR_H /* chr */ +typedef int (*HPMHOOK_pre_chr_waiting_disconnect) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chr_waiting_disconnect) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_chr_delete_char_sql) (int *char_id); +typedef int (*HPMHOOK_post_chr_delete_char_sql) (int retVal___, int char_id); +typedef struct DBData (*HPMHOOK_pre_chr_create_online_char_data) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_chr_create_online_char_data) (struct DBData retVal___, union DBKey key, va_list args); +typedef void (*HPMHOOK_pre_chr_set_account_online) (int *account_id); +typedef void (*HPMHOOK_post_chr_set_account_online) (int account_id); +typedef void (*HPMHOOK_pre_chr_set_account_offline) (int *account_id); +typedef void (*HPMHOOK_post_chr_set_account_offline) (int account_id); +typedef void (*HPMHOOK_pre_chr_set_char_charselect) (int *account_id); +typedef void (*HPMHOOK_post_chr_set_char_charselect) (int account_id); +typedef void (*HPMHOOK_pre_chr_set_char_online) (int *map_id, int *char_id, int *account_id); +typedef void (*HPMHOOK_post_chr_set_char_online) (int map_id, int char_id, int account_id); +typedef void (*HPMHOOK_pre_chr_set_char_offline) (int *char_id, int *account_id); +typedef void (*HPMHOOK_post_chr_set_char_offline) (int char_id, int account_id); +typedef int (*HPMHOOK_pre_chr_db_setoffline) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chr_db_setoffline) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_chr_db_kickoffline) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chr_db_kickoffline) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_chr_set_login_all_offline) (void); +typedef void (*HPMHOOK_post_chr_set_login_all_offline) (void); +typedef void (*HPMHOOK_pre_chr_set_all_offline) (int *id); +typedef void (*HPMHOOK_post_chr_set_all_offline) (int id); +typedef void (*HPMHOOK_pre_chr_set_all_offline_sql) (void); +typedef void (*HPMHOOK_post_chr_set_all_offline_sql) (void); +typedef struct DBData (*HPMHOOK_pre_chr_create_charstatus) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_chr_create_charstatus) (struct DBData retVal___, union DBKey key, va_list args); +typedef int (*HPMHOOK_pre_chr_mmo_char_tosql) (int *char_id, struct mmo_charstatus **p); +typedef int (*HPMHOOK_post_chr_mmo_char_tosql) (int retVal___, int char_id, struct mmo_charstatus *p); +typedef int (*HPMHOOK_pre_chr_memitemdata_to_sql) (const struct item *items[], int *max, int *id, int *tableswitch); +typedef int (*HPMHOOK_post_chr_memitemdata_to_sql) (int retVal___, const struct item items[], int max, int id, int tableswitch); +typedef int (*HPMHOOK_pre_chr_mmo_gender) (const struct char_session_data **sd, const struct mmo_charstatus **p, char *sex); +typedef int (*HPMHOOK_post_chr_mmo_gender) (int retVal___, const struct char_session_data *sd, const struct mmo_charstatus *p, char sex); +typedef int (*HPMHOOK_pre_chr_mmo_chars_fromsql) (struct char_session_data **sd, uint8 **buf); +typedef int (*HPMHOOK_post_chr_mmo_chars_fromsql) (int retVal___, struct char_session_data *sd, uint8 *buf); +typedef int (*HPMHOOK_pre_chr_mmo_char_fromsql) (int *char_id, struct mmo_charstatus **p, bool *load_everything); +typedef int (*HPMHOOK_post_chr_mmo_char_fromsql) (int retVal___, int char_id, struct mmo_charstatus *p, bool load_everything); +typedef int (*HPMHOOK_pre_chr_mmo_char_sql_init) (void); +typedef int (*HPMHOOK_post_chr_mmo_char_sql_init) (int retVal___); +typedef bool (*HPMHOOK_pre_chr_char_slotchange) (struct char_session_data **sd, int *fd, unsigned short *from, unsigned short *to); +typedef bool (*HPMHOOK_post_chr_char_slotchange) (bool retVal___, struct char_session_data *sd, int fd, unsigned short from, unsigned short to); +typedef int (*HPMHOOK_pre_chr_rename_char_sql) (struct char_session_data **sd, int *char_id); +typedef int (*HPMHOOK_post_chr_rename_char_sql) (int retVal___, struct char_session_data *sd, int char_id); +typedef int (*HPMHOOK_pre_chr_check_char_name) (char **name, char **esc_name); +typedef int (*HPMHOOK_post_chr_check_char_name) (int retVal___, char *name, char *esc_name); +typedef int (*HPMHOOK_pre_chr_make_new_char_sql) (struct char_session_data **sd, const char **name_, int *str, int *agi, int *vit, int *int_, int *dex, int *luk, int *slot, int *hair_color, int *hair_style); +typedef int (*HPMHOOK_post_chr_make_new_char_sql) (int retVal___, struct char_session_data *sd, const char *name_, int str, int agi, int vit, int int_, int dex, int luk, int slot, int hair_color, int hair_style); +typedef int (*HPMHOOK_pre_chr_divorce_char_sql) (int *partner_id1, int *partner_id2); +typedef int (*HPMHOOK_post_chr_divorce_char_sql) (int retVal___, int partner_id1, int partner_id2); +typedef int (*HPMHOOK_pre_chr_count_users) (void); +typedef int (*HPMHOOK_post_chr_count_users) (int retVal___); +typedef int (*HPMHOOK_pre_chr_mmo_char_tobuf) (uint8 **buffer, struct mmo_charstatus **p); +typedef int (*HPMHOOK_post_chr_mmo_char_tobuf) (int retVal___, uint8 *buffer, struct mmo_charstatus *p); +typedef void (*HPMHOOK_pre_chr_mmo_char_send099d) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_mmo_char_send099d) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_mmo_char_send_ban_list) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_mmo_char_send_ban_list) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_mmo_char_send_slots_info) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_mmo_char_send_slots_info) (int fd, struct char_session_data *sd); +typedef int (*HPMHOOK_pre_chr_mmo_char_send_characters) (int *fd, struct char_session_data **sd); +typedef int (*HPMHOOK_post_chr_mmo_char_send_characters) (int retVal___, int fd, struct char_session_data *sd); +typedef int (*HPMHOOK_pre_chr_char_married) (int *pl1, int *pl2); +typedef int (*HPMHOOK_post_chr_char_married) (int retVal___, int pl1, int pl2); +typedef int (*HPMHOOK_pre_chr_char_child) (int *parent_id, int *child_id); +typedef int (*HPMHOOK_post_chr_char_child) (int retVal___, int parent_id, int child_id); +typedef int (*HPMHOOK_pre_chr_char_family) (int *cid1, int *cid2, int *cid3); +typedef int (*HPMHOOK_post_chr_char_family) (int retVal___, int cid1, int cid2, int cid3); +typedef void (*HPMHOOK_pre_chr_disconnect_player) (int *account_id); +typedef void (*HPMHOOK_post_chr_disconnect_player) (int account_id); +typedef void (*HPMHOOK_pre_chr_authfail_fd) (int *fd, int *type); +typedef void (*HPMHOOK_post_chr_authfail_fd) (int fd, int type); +typedef void (*HPMHOOK_pre_chr_request_account_data) (int *account_id); +typedef void (*HPMHOOK_post_chr_request_account_data) (int account_id); +typedef void (*HPMHOOK_pre_chr_auth_ok) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_auth_ok) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_ping_login_server) (int *fd); +typedef void (*HPMHOOK_post_chr_ping_login_server) (int fd); +typedef int (*HPMHOOK_pre_chr_parse_fromlogin_connection_state) (int *fd); +typedef int (*HPMHOOK_post_chr_parse_fromlogin_connection_state) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chr_auth_error) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_chr_auth_error) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_auth_state) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_auth_state) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_account_data) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_account_data) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_login_pong) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_login_pong) (int fd); +typedef void (*HPMHOOK_pre_chr_changesex) (int *account_id, int *sex); +typedef void (*HPMHOOK_post_chr_changesex) (int account_id, int sex); +typedef int (*HPMHOOK_pre_chr_parse_fromlogin_changesex_reply) (int *fd); +typedef int (*HPMHOOK_post_chr_parse_fromlogin_changesex_reply) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_account_reg2) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_account_reg2) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_ban) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_ban) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_kick) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_kick) (int fd); +typedef void (*HPMHOOK_pre_chr_update_ip) (int *fd); +typedef void (*HPMHOOK_post_chr_update_ip) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_update_ip) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_update_ip) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_accinfo2_failed) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_accinfo2_failed) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_fromlogin_accinfo2_ok) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_fromlogin_accinfo2_ok) (int fd); +typedef int (*HPMHOOK_pre_chr_parse_fromlogin) (int *fd); +typedef int (*HPMHOOK_post_chr_parse_fromlogin) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_chr_request_accreg2) (int *account_id, int *char_id); +typedef int (*HPMHOOK_post_chr_request_accreg2) (int retVal___, int account_id, int char_id); +typedef void (*HPMHOOK_pre_chr_global_accreg_to_login_start) (int *account_id, int *char_id); +typedef void (*HPMHOOK_post_chr_global_accreg_to_login_start) (int account_id, int char_id); +typedef void (*HPMHOOK_pre_chr_global_accreg_to_login_send) (void); +typedef void (*HPMHOOK_post_chr_global_accreg_to_login_send) (void); +typedef void (*HPMHOOK_pre_chr_global_accreg_to_login_add) (const char **key, unsigned int *index, intptr_t *val, bool *is_string); +typedef void (*HPMHOOK_post_chr_global_accreg_to_login_add) (const char *key, unsigned int index, intptr_t val, bool is_string); +typedef void (*HPMHOOK_pre_chr_read_fame_list) (void); +typedef void (*HPMHOOK_post_chr_read_fame_list) (void); +typedef int (*HPMHOOK_pre_chr_send_fame_list) (int *fd); +typedef int (*HPMHOOK_post_chr_send_fame_list) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chr_update_fame_list) (int *type, int *index, int *fame); +typedef void (*HPMHOOK_post_chr_update_fame_list) (int type, int index, int fame); +typedef int (*HPMHOOK_pre_chr_loadName) (int *char_id, char **name); +typedef int (*HPMHOOK_post_chr_loadName) (int retVal___, int char_id, char *name); +typedef void (*HPMHOOK_pre_chr_parse_frommap_datasync) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_datasync) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_skillid2idx) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_skillid2idx) (int fd); +typedef void (*HPMHOOK_pre_chr_map_received_ok) (int *fd); +typedef void (*HPMHOOK_post_chr_map_received_ok) (int fd); +typedef void (*HPMHOOK_pre_chr_send_maps) (int *fd, int *id, int *j); +typedef void (*HPMHOOK_post_chr_send_maps) (int fd, int id, int j); +typedef void (*HPMHOOK_pre_chr_parse_frommap_map_names) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_map_names) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_send_scdata) (int *fd, int *aid, int *cid); +typedef void (*HPMHOOK_post_chr_send_scdata) (int fd, int aid, int cid); +typedef void (*HPMHOOK_pre_chr_parse_frommap_request_scdata) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_request_scdata) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_set_users_count) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_set_users_count) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_set_users) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_set_users) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_save_character_ack) (int *fd, int *aid, int *cid); +typedef void (*HPMHOOK_post_chr_save_character_ack) (int fd, int aid, int cid); +typedef void (*HPMHOOK_pre_chr_parse_frommap_save_character) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_save_character) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_select_ack) (int *fd, int *account_id, uint8 *flag); +typedef void (*HPMHOOK_post_chr_select_ack) (int fd, int account_id, uint8 flag); +typedef void (*HPMHOOK_pre_chr_parse_frommap_char_select_req) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_char_select_req) (int fd); +typedef void (*HPMHOOK_pre_chr_change_map_server_ack) (int *fd, const uint8 **data, bool *ok); +typedef void (*HPMHOOK_post_chr_change_map_server_ack) (int fd, const uint8 *data, bool ok); +typedef void (*HPMHOOK_pre_chr_parse_frommap_change_map_server) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_change_map_server) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_remove_friend) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_remove_friend) (int fd); +typedef void (*HPMHOOK_pre_chr_char_name_ack) (int *fd, int *char_id); +typedef void (*HPMHOOK_post_chr_char_name_ack) (int fd, int char_id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_char_name_request) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_char_name_request) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_change_email) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_change_email) (int fd); +typedef void (*HPMHOOK_pre_chr_ban) (int *account_id, int *char_id, time_t **unban_time, short *year, short *month, short *day, short *hour, short *minute, short *second); +typedef void (*HPMHOOK_post_chr_ban) (int account_id, int char_id, time_t *unban_time, short year, short month, short day, short hour, short minute, short second); +typedef void (*HPMHOOK_pre_chr_unban) (int *char_id, int **result); +typedef void (*HPMHOOK_post_chr_unban) (int char_id, int *result); +typedef void (*HPMHOOK_pre_chr_ask_name_ack) (int *fd, int *acc, const char **name, int *type, int *result); +typedef void (*HPMHOOK_post_chr_ask_name_ack) (int fd, int acc, const char *name, int type, int result); +typedef int (*HPMHOOK_pre_chr_changecharsex) (int *char_id, int *sex); +typedef int (*HPMHOOK_post_chr_changecharsex) (int retVal___, int char_id, int sex); +typedef void (*HPMHOOK_pre_chr_parse_frommap_change_account) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_change_account) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_fame_list) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_fame_list) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_divorce_char) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_divorce_char) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_ragsrvinfo) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_ragsrvinfo) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_set_char_offline) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_set_char_offline) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_set_all_offline) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_set_all_offline) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_set_char_online) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_set_char_online) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_build_fame_list) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_build_fame_list) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_save_status_change_data) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_save_status_change_data) (int fd); +typedef void (*HPMHOOK_pre_chr_send_pong) (int *fd); +typedef void (*HPMHOOK_post_chr_send_pong) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_ping) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_ping) (int fd); +typedef void (*HPMHOOK_pre_chr_map_auth_ok) (int *fd, int *account_id, struct char_auth_node **node, struct mmo_charstatus **cd); +typedef void (*HPMHOOK_post_chr_map_auth_ok) (int fd, int account_id, struct char_auth_node *node, struct mmo_charstatus *cd); +typedef void (*HPMHOOK_pre_chr_map_auth_failed) (int *fd, int *account_id, int *char_id, int *login_id1, char *sex, uint32 *ip); +typedef void (*HPMHOOK_post_chr_map_auth_failed) (int fd, int account_id, int char_id, int login_id1, char sex, uint32 ip); +typedef void (*HPMHOOK_pre_chr_parse_frommap_auth_request) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_auth_request) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_update_ip) (int *fd, int *id); +typedef void (*HPMHOOK_post_chr_parse_frommap_update_ip) (int fd, int id); +typedef void (*HPMHOOK_pre_chr_parse_frommap_request_stats_report) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_request_stats_report) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_scdata_update) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_scdata_update) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_frommap_scdata_delete) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_frommap_scdata_delete) (int fd); +typedef int (*HPMHOOK_pre_chr_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_chr_parse_frommap) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_chr_search_mapserver) (unsigned short *map, uint32 *ip, uint16 *port); +typedef int (*HPMHOOK_post_chr_search_mapserver) (int retVal___, unsigned short map, uint32 ip, uint16 port); +typedef int (*HPMHOOK_pre_chr_mapif_init) (int *fd); +typedef int (*HPMHOOK_post_chr_mapif_init) (int retVal___, int fd); +typedef uint32 (*HPMHOOK_pre_chr_lan_subnet_check) (uint32 *ip); +typedef uint32 (*HPMHOOK_post_chr_lan_subnet_check) (uint32 retVal___, uint32 ip); +typedef void (*HPMHOOK_pre_chr_delete2_ack) (int *fd, int *char_id, uint32 *result, time_t *delete_date); +typedef void (*HPMHOOK_post_chr_delete2_ack) (int fd, int char_id, uint32 result, time_t delete_date); +typedef void (*HPMHOOK_pre_chr_delete2_accept_actual_ack) (int *fd, int *char_id, uint32 *result); +typedef void (*HPMHOOK_post_chr_delete2_accept_actual_ack) (int fd, int char_id, uint32 result); +typedef void (*HPMHOOK_pre_chr_delete2_accept_ack) (int *fd, int *char_id, uint32 *result); +typedef void (*HPMHOOK_post_chr_delete2_accept_ack) (int fd, int char_id, uint32 result); +typedef void (*HPMHOOK_pre_chr_delete2_cancel_ack) (int *fd, int *char_id, uint32 *result); +typedef void (*HPMHOOK_post_chr_delete2_cancel_ack) (int fd, int char_id, uint32 result); +typedef void (*HPMHOOK_pre_chr_delete2_req) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_delete2_req) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_delete2_accept) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_delete2_accept) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_delete2_cancel) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_delete2_cancel) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_send_account_id) (int *fd, int *account_id); +typedef void (*HPMHOOK_post_chr_send_account_id) (int fd, int account_id); +typedef void (*HPMHOOK_pre_chr_parse_char_connect) (int *fd, struct char_session_data **sd, uint32 *ipl); +typedef void (*HPMHOOK_post_chr_parse_char_connect) (int fd, struct char_session_data *sd, uint32 ipl); +typedef void (*HPMHOOK_pre_chr_send_map_info) (int *fd, int *i, uint32 *subnet_map_ip, struct mmo_charstatus **cd); +typedef void (*HPMHOOK_post_chr_send_map_info) (int fd, int i, uint32 subnet_map_ip, struct mmo_charstatus *cd); +typedef void (*HPMHOOK_pre_chr_send_wait_char_server) (int *fd); +typedef void (*HPMHOOK_post_chr_send_wait_char_server) (int fd); +typedef int (*HPMHOOK_pre_chr_search_default_maps_mapserver) (struct mmo_charstatus **cd); +typedef int (*HPMHOOK_post_chr_search_default_maps_mapserver) (int retVal___, struct mmo_charstatus *cd); +typedef void (*HPMHOOK_pre_chr_parse_char_select) (int *fd, struct char_session_data **sd, uint32 *ipl); +typedef void (*HPMHOOK_post_chr_parse_char_select) (int fd, struct char_session_data *sd, uint32 ipl); +typedef void (*HPMHOOK_pre_chr_creation_failed) (int *fd, int *result); +typedef void (*HPMHOOK_post_chr_creation_failed) (int fd, int result); +typedef void (*HPMHOOK_pre_chr_creation_ok) (int *fd, struct mmo_charstatus **char_dat); +typedef void (*HPMHOOK_post_chr_creation_ok) (int fd, struct mmo_charstatus *char_dat); +typedef void (*HPMHOOK_pre_chr_parse_char_create_new_char) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_create_new_char) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_delete_char_failed) (int *fd, int *flag); +typedef void (*HPMHOOK_post_chr_delete_char_failed) (int fd, int flag); +typedef void (*HPMHOOK_pre_chr_delete_char_ok) (int *fd); +typedef void (*HPMHOOK_post_chr_delete_char_ok) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_char_delete_char) (int *fd, struct char_session_data **sd, unsigned short *cmd); +typedef void (*HPMHOOK_post_chr_parse_char_delete_char) (int fd, struct char_session_data *sd, unsigned short cmd); +typedef void (*HPMHOOK_pre_chr_parse_char_ping) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_char_ping) (int fd); +typedef void (*HPMHOOK_pre_chr_allow_rename) (int *fd, int *flag); +typedef void (*HPMHOOK_post_chr_allow_rename) (int fd, int flag); +typedef void (*HPMHOOK_pre_chr_parse_char_rename_char) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_rename_char) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_rename_char2) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_rename_char2) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_rename_char_ack) (int *fd, int *flag); +typedef void (*HPMHOOK_post_chr_rename_char_ack) (int fd, int flag); +typedef void (*HPMHOOK_pre_chr_parse_char_rename_char_confirm) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_rename_char_confirm) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_captcha_notsupported) (int *fd); +typedef void (*HPMHOOK_post_chr_captcha_notsupported) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_char_request_captcha) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_char_request_captcha) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_char_check_captcha) (int *fd); +typedef void (*HPMHOOK_post_chr_parse_char_check_captcha) (int fd); +typedef void (*HPMHOOK_pre_chr_parse_char_delete2_req) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_delete2_req) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_delete2_accept) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_delete2_accept) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_delete2_cancel) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_delete2_cancel) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_login_map_server_ack) (int *fd, uint8 *flag); +typedef void (*HPMHOOK_post_chr_login_map_server_ack) (int fd, uint8 flag); +typedef void (*HPMHOOK_pre_chr_parse_char_login_map_server) (int *fd, uint32 *ipl); +typedef void (*HPMHOOK_post_chr_parse_char_login_map_server) (int fd, uint32 ipl); +typedef void (*HPMHOOK_pre_chr_parse_char_pincode_check) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_pincode_check) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_pincode_window) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_pincode_window) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_pincode_change) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_pincode_change) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_pincode_first_pin) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_pincode_first_pin) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_parse_char_request_chars) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_request_chars) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_chr_change_character_slot_ack) (int *fd, bool *ret); +typedef void (*HPMHOOK_post_chr_change_character_slot_ack) (int fd, bool ret); +typedef void (*HPMHOOK_pre_chr_parse_char_move_character) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_chr_parse_char_move_character) (int fd, struct char_session_data *sd); +typedef int (*HPMHOOK_pre_chr_parse_char_unknown_packet) (int *fd, uint32 *ipl); +typedef int (*HPMHOOK_post_chr_parse_char_unknown_packet) (int retVal___, int fd, uint32 ipl); +typedef int (*HPMHOOK_pre_chr_parse_char) (int *fd); +typedef int (*HPMHOOK_post_chr_parse_char) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_chr_broadcast_user_count) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chr_broadcast_user_count) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_chr_send_accounts_tologin_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chr_send_accounts_tologin_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_chr_send_accounts_tologin) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chr_send_accounts_tologin) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_chr_check_connect_login_server) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chr_check_connect_login_server) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_chr_online_data_cleanup_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chr_online_data_cleanup_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_chr_online_data_cleanup) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chr_online_data_cleanup) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_chr_sql_config_read) (const char **cfgName); +typedef void (*HPMHOOK_post_chr_sql_config_read) (const char *cfgName); +typedef void (*HPMHOOK_pre_chr_config_dispatch) (char **w1, char **w2); +typedef void (*HPMHOOK_post_chr_config_dispatch) (char *w1, char *w2); +typedef int (*HPMHOOK_pre_chr_config_read) (const char **cfgName); +typedef int (*HPMHOOK_post_chr_config_read) (int retVal___, const char *cfgName); +#endif // CHAR_CHAR_H +#ifdef MAP_CHAT_H /* chat */ +typedef bool (*HPMHOOK_pre_chat_create_pc_chat) (struct map_session_data **sd, const char **title, const char **pass, int *limit, bool *pub); +typedef bool (*HPMHOOK_post_chat_create_pc_chat) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub); +typedef bool (*HPMHOOK_pre_chat_join) (struct map_session_data **sd, int *chatid, const char **pass); +typedef bool (*HPMHOOK_post_chat_join) (bool retVal___, struct map_session_data *sd, int chatid, const char *pass); +typedef int (*HPMHOOK_pre_chat_leave) (struct map_session_data **sd, bool *kicked); +typedef int (*HPMHOOK_post_chat_leave) (int retVal___, struct map_session_data *sd, bool kicked); +typedef bool (*HPMHOOK_pre_chat_change_owner) (struct map_session_data **sd, const char **nextownername); +typedef bool (*HPMHOOK_post_chat_change_owner) (bool retVal___, struct map_session_data *sd, const char *nextownername); +typedef bool (*HPMHOOK_pre_chat_change_status) (struct map_session_data **sd, const char **title, const char **pass, int *limit, bool *pub); +typedef bool (*HPMHOOK_post_chat_change_status) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub); +typedef bool (*HPMHOOK_pre_chat_kick) (struct map_session_data **sd, const char **kickusername); +typedef bool (*HPMHOOK_post_chat_kick) (bool retVal___, struct map_session_data *sd, const char *kickusername); +typedef bool (*HPMHOOK_pre_chat_create_npc_chat) (struct npc_data **nd, const char **title, int *limit, bool *pub, int *trigger, const char **ev, int *zeny, int *minLvl, int *maxLvl); +typedef bool (*HPMHOOK_post_chat_create_npc_chat) (bool retVal___, struct npc_data *nd, const char *title, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl); +typedef bool (*HPMHOOK_pre_chat_delete_npc_chat) (struct npc_data **nd); +typedef bool (*HPMHOOK_post_chat_delete_npc_chat) (bool retVal___, struct npc_data *nd); +typedef bool (*HPMHOOK_pre_chat_enable_event) (struct chat_data **cd); +typedef bool (*HPMHOOK_post_chat_enable_event) (bool retVal___, struct chat_data *cd); +typedef bool (*HPMHOOK_pre_chat_disable_event) (struct chat_data **cd); +typedef bool (*HPMHOOK_post_chat_disable_event) (bool retVal___, struct chat_data *cd); +typedef bool (*HPMHOOK_pre_chat_npc_kick_all) (struct chat_data **cd); +typedef bool (*HPMHOOK_post_chat_npc_kick_all) (bool retVal___, struct chat_data *cd); +typedef bool (*HPMHOOK_pre_chat_trigger_event) (struct chat_data **cd); +typedef bool (*HPMHOOK_post_chat_trigger_event) (bool retVal___, struct chat_data *cd); +typedef struct chat_data* (*HPMHOOK_pre_chat_create) (struct block_list **bl, const char **title, const char **pass, int *limit, bool *pub, int *trigger, const char **ev, int *zeny, int *minLvl, int *maxLvl); +typedef struct chat_data* (*HPMHOOK_post_chat_create) (struct chat_data* retVal___, struct block_list *bl, const char *title, const char *pass, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl); +#endif // MAP_CHAT_H +#ifdef MAP_CHRIF_H /* chrif */ +typedef void (*HPMHOOK_pre_chrif_init) (bool *minimal); +typedef void (*HPMHOOK_post_chrif_init) (bool minimal); +typedef void (*HPMHOOK_pre_chrif_final) (void); +typedef void (*HPMHOOK_post_chrif_final) (void); +typedef void (*HPMHOOK_pre_chrif_setuserid) (char **id); +typedef void (*HPMHOOK_post_chrif_setuserid) (char *id); +typedef void (*HPMHOOK_pre_chrif_setpasswd) (char **pwd); +typedef void (*HPMHOOK_post_chrif_setpasswd) (char *pwd); +typedef void (*HPMHOOK_pre_chrif_checkdefaultlogin) (void); +typedef void (*HPMHOOK_post_chrif_checkdefaultlogin) (void); +typedef bool (*HPMHOOK_pre_chrif_setip) (const char **ip); +typedef bool (*HPMHOOK_post_chrif_setip) (bool retVal___, const char *ip); +typedef void (*HPMHOOK_pre_chrif_setport) (uint16 *port); +typedef void (*HPMHOOK_post_chrif_setport) (uint16 port); +typedef int (*HPMHOOK_pre_chrif_isconnected) (void); +typedef int (*HPMHOOK_post_chrif_isconnected) (int retVal___); +typedef void (*HPMHOOK_pre_chrif_check_shutdown) (void); +typedef void (*HPMHOOK_post_chrif_check_shutdown) (void); +typedef struct auth_node* (*HPMHOOK_pre_chrif_search) (int *account_id); +typedef struct auth_node* (*HPMHOOK_post_chrif_search) (struct auth_node* retVal___, int account_id); +typedef struct auth_node* (*HPMHOOK_pre_chrif_auth_check) (int *account_id, int *char_id, enum sd_state *state); +typedef struct auth_node* (*HPMHOOK_post_chrif_auth_check) (struct auth_node* retVal___, int account_id, int char_id, enum sd_state state); +typedef bool (*HPMHOOK_pre_chrif_auth_delete) (int *account_id, int *char_id, enum sd_state *state); +typedef bool (*HPMHOOK_post_chrif_auth_delete) (bool retVal___, int account_id, int char_id, enum sd_state state); +typedef bool (*HPMHOOK_pre_chrif_auth_finished) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_chrif_auth_finished) (bool retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_chrif_authreq) (struct map_session_data **sd, bool *hstandalone); +typedef void (*HPMHOOK_post_chrif_authreq) (struct map_session_data *sd, bool hstandalone); +typedef void (*HPMHOOK_pre_chrif_authok) (int *fd); +typedef void (*HPMHOOK_post_chrif_authok) (int fd); +typedef bool (*HPMHOOK_pre_chrif_scdata_request) (int *account_id, int *char_id); +typedef bool (*HPMHOOK_post_chrif_scdata_request) (bool retVal___, int account_id, int char_id); +typedef bool (*HPMHOOK_pre_chrif_save) (struct map_session_data **sd, int *flag); +typedef bool (*HPMHOOK_post_chrif_save) (bool retVal___, struct map_session_data *sd, int flag); +typedef bool (*HPMHOOK_pre_chrif_charselectreq) (struct map_session_data **sd, uint32 *s_ip); +typedef bool (*HPMHOOK_post_chrif_charselectreq) (bool retVal___, struct map_session_data *sd, uint32 s_ip); +typedef bool (*HPMHOOK_pre_chrif_changemapserver) (struct map_session_data **sd, uint32 *ip, uint16 *port); +typedef bool (*HPMHOOK_post_chrif_changemapserver) (bool retVal___, struct map_session_data *sd, uint32 ip, uint16 port); +typedef bool (*HPMHOOK_pre_chrif_searchcharid) (int *char_id); +typedef bool (*HPMHOOK_post_chrif_searchcharid) (bool retVal___, int char_id); +typedef bool (*HPMHOOK_pre_chrif_changeemail) (int *id, const char **actual_email, const char **new_email); +typedef bool (*HPMHOOK_post_chrif_changeemail) (bool retVal___, int id, const char *actual_email, const char *new_email); +typedef bool (*HPMHOOK_pre_chrif_char_ask_name) (int *acc, const char **character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second); +typedef bool (*HPMHOOK_post_chrif_char_ask_name) (bool retVal___, int acc, const char *character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second); +typedef int (*HPMHOOK_pre_chrif_updatefamelist) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_chrif_updatefamelist) (int retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_chrif_buildfamelist) (void); +typedef bool (*HPMHOOK_post_chrif_buildfamelist) (bool retVal___); +typedef bool (*HPMHOOK_pre_chrif_save_scdata) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_chrif_save_scdata) (bool retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_chrif_ragsrvinfo) (int *base_rate, int *job_rate, int *drop_rate); +typedef bool (*HPMHOOK_post_chrif_ragsrvinfo) (bool retVal___, int base_rate, int job_rate, int drop_rate); +typedef bool (*HPMHOOK_pre_chrif_char_offline_nsd) (int *account_id, int *char_id); +typedef bool (*HPMHOOK_post_chrif_char_offline_nsd) (bool retVal___, int account_id, int char_id); +typedef bool (*HPMHOOK_pre_chrif_char_reset_offline) (void); +typedef bool (*HPMHOOK_post_chrif_char_reset_offline) (bool retVal___); +typedef bool (*HPMHOOK_pre_chrif_send_users_tochar) (void); +typedef bool (*HPMHOOK_post_chrif_send_users_tochar) (bool retVal___); +typedef bool (*HPMHOOK_pre_chrif_char_online) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_chrif_char_online) (bool retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_chrif_changesex) (struct map_session_data **sd, bool *change_account); +typedef bool (*HPMHOOK_post_chrif_changesex) (bool retVal___, struct map_session_data *sd, bool change_account); +typedef bool (*HPMHOOK_pre_chrif_divorce) (int *partner_id1, int *partner_id2); +typedef bool (*HPMHOOK_post_chrif_divorce) (bool retVal___, int partner_id1, int partner_id2); +typedef bool (*HPMHOOK_pre_chrif_removefriend) (int *char_id, int *friend_id); +typedef bool (*HPMHOOK_post_chrif_removefriend) (bool retVal___, int char_id, int friend_id); +typedef void (*HPMHOOK_pre_chrif_send_report) (char **buf, int *len); +typedef void (*HPMHOOK_post_chrif_send_report) (char *buf, int len); +typedef bool (*HPMHOOK_pre_chrif_flush) (void); +typedef bool (*HPMHOOK_post_chrif_flush) (bool retVal___); +typedef void (*HPMHOOK_pre_chrif_skillid2idx) (int *fd); +typedef void (*HPMHOOK_post_chrif_skillid2idx) (int fd); +typedef bool (*HPMHOOK_pre_chrif_sd_to_auth) (struct map_session_data **sd, enum sd_state *state); +typedef bool (*HPMHOOK_post_chrif_sd_to_auth) (bool retVal___, struct map_session_data *sd, enum sd_state state); +typedef int (*HPMHOOK_pre_chrif_check_connect_char_server) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chrif_check_connect_char_server) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef bool (*HPMHOOK_pre_chrif_auth_logout) (struct map_session_data **sd, enum sd_state *state); +typedef bool (*HPMHOOK_post_chrif_auth_logout) (bool retVal___, struct map_session_data *sd, enum sd_state state); +typedef void (*HPMHOOK_pre_chrif_save_ack) (int *fd); +typedef void (*HPMHOOK_post_chrif_save_ack) (int fd); +typedef int (*HPMHOOK_pre_chrif_reconnect) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chrif_reconnect) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_chrif_auth_db_cleanup_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chrif_auth_db_cleanup_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef bool (*HPMHOOK_pre_chrif_char_ask_name_answer) (int *acc, const char **player_name, uint16 *type, uint16 *answer); +typedef bool (*HPMHOOK_post_chrif_char_ask_name_answer) (bool retVal___, int acc, const char *player_name, uint16 type, uint16 answer); +typedef int (*HPMHOOK_pre_chrif_auth_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_chrif_auth_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_chrif_send_usercount_tochar) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chrif_send_usercount_tochar) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_chrif_auth_db_cleanup) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_chrif_auth_db_cleanup) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_chrif_connect) (int *fd); +typedef void (*HPMHOOK_post_chrif_connect) (int fd); +typedef void (*HPMHOOK_pre_chrif_connectack) (int *fd); +typedef void (*HPMHOOK_post_chrif_connectack) (int fd); +typedef void (*HPMHOOK_pre_chrif_sendmap) (int *fd); +typedef void (*HPMHOOK_post_chrif_sendmap) (int fd); +typedef void (*HPMHOOK_pre_chrif_sendmapack) (int *fd); +typedef void (*HPMHOOK_post_chrif_sendmapack) (int fd); +typedef void (*HPMHOOK_pre_chrif_recvmap) (int *fd); +typedef void (*HPMHOOK_post_chrif_recvmap) (int fd); +typedef bool (*HPMHOOK_pre_chrif_changemapserverack) (int *account_id, int *login_id1, int *login_id2, int *char_id, short *map_index, short *x, short *y, uint32 *ip, uint16 *port); +typedef bool (*HPMHOOK_post_chrif_changemapserverack) (bool retVal___, int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port); +typedef void (*HPMHOOK_pre_chrif_changedsex) (int *fd); +typedef void (*HPMHOOK_post_chrif_changedsex) (int fd); +typedef bool (*HPMHOOK_pre_chrif_divorceack) (int *char_id, int *partner_id); +typedef bool (*HPMHOOK_post_chrif_divorceack) (bool retVal___, int char_id, int partner_id); +typedef void (*HPMHOOK_pre_chrif_idbanned) (int *fd); +typedef void (*HPMHOOK_post_chrif_idbanned) (int fd); +typedef void (*HPMHOOK_pre_chrif_recvfamelist) (int *fd); +typedef void (*HPMHOOK_post_chrif_recvfamelist) (int fd); +typedef bool (*HPMHOOK_pre_chrif_load_scdata) (int *fd); +typedef bool (*HPMHOOK_post_chrif_load_scdata) (bool retVal___, int fd); +typedef void (*HPMHOOK_pre_chrif_update_ip) (int *fd); +typedef void (*HPMHOOK_post_chrif_update_ip) (int fd); +typedef int (*HPMHOOK_pre_chrif_disconnectplayer) (int *fd); +typedef int (*HPMHOOK_post_chrif_disconnectplayer) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chrif_removemap) (int *fd); +typedef void (*HPMHOOK_post_chrif_removemap) (int fd); +typedef int (*HPMHOOK_pre_chrif_updatefamelist_ack) (int *fd); +typedef int (*HPMHOOK_post_chrif_updatefamelist_ack) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chrif_keepalive) (int *fd); +typedef void (*HPMHOOK_post_chrif_keepalive) (int fd); +typedef void (*HPMHOOK_pre_chrif_keepalive_ack) (int *fd); +typedef void (*HPMHOOK_post_chrif_keepalive_ack) (int fd); +typedef void (*HPMHOOK_pre_chrif_deadopt) (int *father_id, int *mother_id, int *child_id); +typedef void (*HPMHOOK_post_chrif_deadopt) (int father_id, int mother_id, int child_id); +typedef void (*HPMHOOK_pre_chrif_authfail) (int *fd); +typedef void (*HPMHOOK_post_chrif_authfail) (int fd); +typedef void (*HPMHOOK_pre_chrif_on_ready) (void); +typedef void (*HPMHOOK_post_chrif_on_ready) (void); +typedef void (*HPMHOOK_pre_chrif_on_disconnect) (void); +typedef void (*HPMHOOK_post_chrif_on_disconnect) (void); +typedef int (*HPMHOOK_pre_chrif_parse) (int *fd); +typedef int (*HPMHOOK_post_chrif_parse) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_chrif_save_scdata_single) (int *account_id, int *char_id, short *type, struct status_change_entry **sce); +typedef void (*HPMHOOK_post_chrif_save_scdata_single) (int account_id, int char_id, short type, struct status_change_entry *sce); +typedef void (*HPMHOOK_pre_chrif_del_scdata_single) (int *account_id, int *char_id, short *type); +typedef void (*HPMHOOK_post_chrif_del_scdata_single) (int account_id, int char_id, short type); +#endif // MAP_CHRIF_H +#ifdef MAP_CLIF_H /* clif */ +typedef int (*HPMHOOK_pre_clif_init) (bool *minimal); +typedef int (*HPMHOOK_post_clif_init) (int retVal___, bool minimal); +typedef void (*HPMHOOK_pre_clif_final) (void); +typedef void (*HPMHOOK_post_clif_final) (void); +typedef bool (*HPMHOOK_pre_clif_setip) (const char **ip); +typedef bool (*HPMHOOK_post_clif_setip) (bool retVal___, const char *ip); +typedef bool (*HPMHOOK_pre_clif_setbindip) (const char **ip); +typedef bool (*HPMHOOK_post_clif_setbindip) (bool retVal___, const char *ip); +typedef void (*HPMHOOK_pre_clif_setport) (uint16 *port); +typedef void (*HPMHOOK_post_clif_setport) (uint16 port); +typedef uint32 (*HPMHOOK_pre_clif_refresh_ip) (void); +typedef uint32 (*HPMHOOK_post_clif_refresh_ip) (uint32 retVal___); +typedef bool (*HPMHOOK_pre_clif_send) (const void **buf, int *len, struct block_list **bl, enum send_target *type); +typedef bool (*HPMHOOK_post_clif_send) (bool retVal___, const void *buf, int len, struct block_list *bl, enum send_target type); +typedef int (*HPMHOOK_pre_clif_send_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_clif_send_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_clif_send_actual) (int *fd, void **buf, int *len); +typedef int (*HPMHOOK_post_clif_send_actual) (int retVal___, int fd, void *buf, int len); +typedef int (*HPMHOOK_pre_clif_parse) (int *fd); +typedef int (*HPMHOOK_post_clif_parse) (int retVal___, int fd); +typedef const struct s_packet_db* (*HPMHOOK_pre_clif_packet) (int *packet_id); +typedef const struct s_packet_db* (*HPMHOOK_post_clif_packet) (const struct s_packet_db* retVal___, int packet_id); +typedef unsigned short (*HPMHOOK_pre_clif_parse_cmd) (int *fd, struct map_session_data **sd); +typedef unsigned short (*HPMHOOK_post_clif_parse_cmd) (unsigned short retVal___, int fd, struct map_session_data *sd); +typedef unsigned short (*HPMHOOK_pre_clif_decrypt_cmd) (int *cmd, struct map_session_data **sd); +typedef unsigned short (*HPMHOOK_post_clif_decrypt_cmd) (unsigned short retVal___, int cmd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_authok) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_authok) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_authrefuse) (int *fd, uint8 *error_code); +typedef void (*HPMHOOK_post_clif_authrefuse) (int fd, uint8 error_code); +typedef void (*HPMHOOK_pre_clif_authfail_fd) (int *fd, int *type); +typedef void (*HPMHOOK_post_clif_authfail_fd) (int fd, int type); +typedef void (*HPMHOOK_pre_clif_charselectok) (int *id, uint8 *ok); +typedef void (*HPMHOOK_post_clif_charselectok) (int id, uint8 ok); +typedef void (*HPMHOOK_pre_clif_dropflooritem) (struct flooritem_data **fitem); +typedef void (*HPMHOOK_post_clif_dropflooritem) (struct flooritem_data *fitem); +typedef void (*HPMHOOK_pre_clif_clearflooritem) (struct flooritem_data **fitem, int *fd); +typedef void (*HPMHOOK_post_clif_clearflooritem) (struct flooritem_data *fitem, int fd); +typedef void (*HPMHOOK_pre_clif_additem) (struct map_session_data **sd, int *n, int *amount, int *fail); +typedef void (*HPMHOOK_post_clif_additem) (struct map_session_data *sd, int n, int amount, int fail); +typedef void (*HPMHOOK_pre_clif_dropitem) (struct map_session_data **sd, int *n, int *amount); +typedef void (*HPMHOOK_post_clif_dropitem) (struct map_session_data *sd, int n, int amount); +typedef void (*HPMHOOK_pre_clif_delitem) (struct map_session_data **sd, int *n, int *amount, short *reason); +typedef void (*HPMHOOK_post_clif_delitem) (struct map_session_data *sd, int n, int amount, short reason); +typedef void (*HPMHOOK_pre_clif_takeitem) (struct block_list **src, struct block_list **dst); +typedef void (*HPMHOOK_post_clif_takeitem) (struct block_list *src, struct block_list *dst); +typedef void (*HPMHOOK_pre_clif_item_equip) (short *idx, struct EQUIPITEM_INFO **p, struct item **i, struct item_data **id, int *eqp_pos); +typedef void (*HPMHOOK_post_clif_item_equip) (short idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int eqp_pos); +typedef void (*HPMHOOK_pre_clif_item_normal) (short *idx, struct NORMALITEM_INFO **p, struct item **i, struct item_data **id); +typedef void (*HPMHOOK_post_clif_item_normal) (short idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id); +typedef void (*HPMHOOK_pre_clif_arrowequip) (struct map_session_data **sd, int *val); +typedef void (*HPMHOOK_post_clif_arrowequip) (struct map_session_data *sd, int val); +typedef void (*HPMHOOK_pre_clif_arrow_fail) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_arrow_fail) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_use_card) (struct map_session_data **sd, int *idx); +typedef void (*HPMHOOK_post_clif_use_card) (struct map_session_data *sd, int idx); +typedef void (*HPMHOOK_pre_clif_cart_additem) (struct map_session_data **sd, int *n, int *amount, int *fail); +typedef void (*HPMHOOK_post_clif_cart_additem) (struct map_session_data *sd, int n, int amount, int fail); +typedef void (*HPMHOOK_pre_clif_cart_delitem) (struct map_session_data **sd, int *n, int *amount); +typedef void (*HPMHOOK_post_clif_cart_delitem) (struct map_session_data *sd, int n, int amount); +typedef void (*HPMHOOK_pre_clif_equipitemack) (struct map_session_data **sd, int *n, int *pos, enum e_EQUIP_ITEM_ACK *result); +typedef void (*HPMHOOK_post_clif_equipitemack) (struct map_session_data *sd, int n, int pos, enum e_EQUIP_ITEM_ACK result); +typedef void (*HPMHOOK_pre_clif_unequipitemack) (struct map_session_data **sd, int *n, int *pos, enum e_UNEQUIP_ITEM_ACK *result); +typedef void (*HPMHOOK_post_clif_unequipitemack) (struct map_session_data *sd, int n, int pos, enum e_UNEQUIP_ITEM_ACK result); +typedef void (*HPMHOOK_pre_clif_useitemack) (struct map_session_data **sd, int *index, int *amount, bool *ok); +typedef void (*HPMHOOK_post_clif_useitemack) (struct map_session_data *sd, int index, int amount, bool ok); +typedef void (*HPMHOOK_pre_clif_addcards) (unsigned char **buf, struct item **item); +typedef void (*HPMHOOK_post_clif_addcards) (unsigned char *buf, struct item *item); +typedef void (*HPMHOOK_pre_clif_addcards2) (unsigned short **cards, struct item **item); +typedef void (*HPMHOOK_post_clif_addcards2) (unsigned short *cards, struct item *item); +typedef void (*HPMHOOK_pre_clif_item_sub) (unsigned char **buf, int *n, struct item **i, struct item_data **id, int *equip); +typedef void (*HPMHOOK_post_clif_item_sub) (unsigned char *buf, int n, struct item *i, struct item_data *id, int equip); +typedef void (*HPMHOOK_pre_clif_getareachar_item) (struct map_session_data **sd, struct flooritem_data **fitem); +typedef void (*HPMHOOK_post_clif_getareachar_item) (struct map_session_data *sd, struct flooritem_data *fitem); +typedef void (*HPMHOOK_pre_clif_cart_additem_ack) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_cart_additem_ack) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_cashshop_load) (void); +typedef void (*HPMHOOK_post_clif_cashshop_load) (void); +typedef void (*HPMHOOK_pre_clif_package_announce) (struct map_session_data **sd, unsigned short *nameid, unsigned short *containerid); +typedef void (*HPMHOOK_post_clif_package_announce) (struct map_session_data *sd, unsigned short nameid, unsigned short containerid); +typedef void (*HPMHOOK_pre_clif_item_drop_announce) (struct map_session_data **sd, unsigned short *nameid, char **monsterName); +typedef void (*HPMHOOK_post_clif_item_drop_announce) (struct map_session_data *sd, unsigned short nameid, char *monsterName); +typedef void (*HPMHOOK_pre_clif_clearunit_single) (int *id, clr_type *type, int *fd); +typedef void (*HPMHOOK_post_clif_clearunit_single) (int id, clr_type type, int fd); +typedef void (*HPMHOOK_pre_clif_clearunit_area) (struct block_list **bl, clr_type *type); +typedef void (*HPMHOOK_post_clif_clearunit_area) (struct block_list *bl, clr_type type); +typedef void (*HPMHOOK_pre_clif_clearunit_delayed) (struct block_list **bl, clr_type *type, int64 *tick); +typedef void (*HPMHOOK_post_clif_clearunit_delayed) (struct block_list *bl, clr_type type, int64 tick); +typedef void (*HPMHOOK_pre_clif_walkok) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_walkok) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_move) (struct unit_data **ud); +typedef void (*HPMHOOK_post_clif_move) (struct unit_data *ud); +typedef void (*HPMHOOK_pre_clif_move2) (struct block_list **bl, struct view_data **vd, struct unit_data **ud); +typedef void (*HPMHOOK_post_clif_move2) (struct block_list *bl, struct view_data *vd, struct unit_data *ud); +typedef void (*HPMHOOK_pre_clif_blown) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_blown) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_slide) (struct block_list **bl, int *x, int *y); +typedef void (*HPMHOOK_post_clif_slide) (struct block_list *bl, int x, int y); +typedef void (*HPMHOOK_pre_clif_fixpos) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_fixpos) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_changelook) (struct block_list **bl, int *type, int *val); +typedef void (*HPMHOOK_post_clif_changelook) (struct block_list *bl, int type, int val); +typedef void (*HPMHOOK_pre_clif_changetraplook) (struct block_list **bl, int *val); +typedef void (*HPMHOOK_post_clif_changetraplook) (struct block_list *bl, int val); +typedef void (*HPMHOOK_pre_clif_refreshlook) (struct block_list **bl, int *id, int *type, int *val, enum send_target *target); +typedef void (*HPMHOOK_post_clif_refreshlook) (struct block_list *bl, int id, int type, int val, enum send_target target); +typedef void (*HPMHOOK_pre_clif_sendlook) (struct block_list **bl, int *id, int *type, int *val, int *val2, enum send_target *target); +typedef void (*HPMHOOK_post_clif_sendlook) (struct block_list *bl, int id, int type, int val, int val2, enum send_target target); +typedef void (*HPMHOOK_pre_clif_class_change) (struct block_list **bl, int *class_, int *type); +typedef void (*HPMHOOK_post_clif_class_change) (struct block_list *bl, int class_, int type); +typedef void (*HPMHOOK_pre_clif_skill_delunit) (struct skill_unit **su); +typedef void (*HPMHOOK_post_clif_skill_delunit) (struct skill_unit *su); +typedef void (*HPMHOOK_pre_clif_skillunit_update) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_skillunit_update) (struct block_list *bl); +typedef int (*HPMHOOK_pre_clif_clearunit_delayed_sub) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_clif_clearunit_delayed_sub) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_clif_set_unit_idle) (struct block_list **bl, struct map_session_data **tsd, enum send_target *target); +typedef void (*HPMHOOK_post_clif_set_unit_idle) (struct block_list *bl, struct map_session_data *tsd, enum send_target target); +typedef void (*HPMHOOK_pre_clif_spawn_unit) (struct block_list **bl, enum send_target *target); +typedef void (*HPMHOOK_post_clif_spawn_unit) (struct block_list *bl, enum send_target target); +typedef void (*HPMHOOK_pre_clif_spawn_unit2) (struct block_list **bl, enum send_target *target); +typedef void (*HPMHOOK_post_clif_spawn_unit2) (struct block_list *bl, enum send_target target); +typedef void (*HPMHOOK_pre_clif_set_unit_idle2) (struct block_list **bl, struct map_session_data **tsd, enum send_target *target); +typedef void (*HPMHOOK_post_clif_set_unit_idle2) (struct block_list *bl, struct map_session_data *tsd, enum send_target target); +typedef void (*HPMHOOK_pre_clif_set_unit_walking) (struct block_list **bl, struct map_session_data **tsd, struct unit_data **ud, enum send_target *target); +typedef void (*HPMHOOK_post_clif_set_unit_walking) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target); +typedef int (*HPMHOOK_pre_clif_calc_walkdelay) (struct block_list **bl, int *delay, int *type, int *damage, int *div_); +typedef int (*HPMHOOK_post_clif_calc_walkdelay) (int retVal___, struct block_list *bl, int delay, int type, int damage, int div_); +typedef void (*HPMHOOK_pre_clif_getareachar_skillunit) (struct block_list **bl, struct skill_unit **su, enum send_target *target); +typedef void (*HPMHOOK_post_clif_getareachar_skillunit) (struct block_list *bl, struct skill_unit *su, enum send_target target); +typedef void (*HPMHOOK_pre_clif_getareachar_unit) (struct map_session_data **sd, struct block_list **bl); +typedef void (*HPMHOOK_post_clif_getareachar_unit) (struct map_session_data *sd, struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_clearchar_skillunit) (struct skill_unit **su, int *fd); +typedef void (*HPMHOOK_post_clif_clearchar_skillunit) (struct skill_unit *su, int fd); +typedef int (*HPMHOOK_pre_clif_getareachar) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_clif_getareachar) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_clif_graffiti_entry) (struct block_list **bl, struct skill_unit **su, enum send_target *target); +typedef void (*HPMHOOK_post_clif_graffiti_entry) (struct block_list *bl, struct skill_unit *su, enum send_target target); +typedef bool (*HPMHOOK_pre_clif_spawn) (struct block_list **bl); +typedef bool (*HPMHOOK_post_clif_spawn) (bool retVal___, struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_changemap) (struct map_session_data **sd, short *m, int *x, int *y); +typedef void (*HPMHOOK_post_clif_changemap) (struct map_session_data *sd, short m, int x, int y); +typedef void (*HPMHOOK_pre_clif_changemapcell) (int *fd, int16 *m, int *x, int *y, int *type, enum send_target *target); +typedef void (*HPMHOOK_post_clif_changemapcell) (int fd, int16 m, int x, int y, int type, enum send_target target); +typedef void (*HPMHOOK_pre_clif_map_property) (struct map_session_data **sd, enum map_property *property); +typedef void (*HPMHOOK_post_clif_map_property) (struct map_session_data *sd, enum map_property property); +typedef void (*HPMHOOK_pre_clif_pvpset) (struct map_session_data **sd, int *pvprank, int *pvpnum, int *type); +typedef void (*HPMHOOK_post_clif_pvpset) (struct map_session_data *sd, int pvprank, int pvpnum, int type); +typedef void (*HPMHOOK_pre_clif_map_property_mapall) (int *mapid, enum map_property *property); +typedef void (*HPMHOOK_post_clif_map_property_mapall) (int mapid, enum map_property property); +typedef void (*HPMHOOK_pre_clif_bossmapinfo) (int *fd, struct mob_data **md, short *flag); +typedef void (*HPMHOOK_post_clif_bossmapinfo) (int fd, struct mob_data *md, short flag); +typedef void (*HPMHOOK_pre_clif_map_type) (struct map_session_data **sd, enum map_type *type); +typedef void (*HPMHOOK_post_clif_map_type) (struct map_session_data *sd, enum map_type type); +typedef void (*HPMHOOK_pre_clif_maptypeproperty2) (struct block_list **bl, enum send_target *t); +typedef void (*HPMHOOK_post_clif_maptypeproperty2) (struct block_list *bl, enum send_target t); +typedef void (*HPMHOOK_pre_clif_changemapserver) (struct map_session_data **sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port); +typedef void (*HPMHOOK_post_clif_changemapserver) (struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port); +typedef void (*HPMHOOK_pre_clif_npcbuysell) (struct map_session_data **sd, int *id); +typedef void (*HPMHOOK_post_clif_npcbuysell) (struct map_session_data *sd, int id); +typedef void (*HPMHOOK_pre_clif_buylist) (struct map_session_data **sd, struct npc_data **nd); +typedef void (*HPMHOOK_post_clif_buylist) (struct map_session_data *sd, struct npc_data *nd); +typedef void (*HPMHOOK_pre_clif_selllist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_selllist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_cashshop_show) (struct map_session_data **sd, struct npc_data **nd); +typedef void (*HPMHOOK_post_clif_cashshop_show) (struct map_session_data *sd, struct npc_data *nd); +typedef void (*HPMHOOK_pre_clif_npc_buy_result) (struct map_session_data **sd, unsigned char *result); +typedef void (*HPMHOOK_post_clif_npc_buy_result) (struct map_session_data *sd, unsigned char result); +typedef void (*HPMHOOK_pre_clif_npc_sell_result) (struct map_session_data **sd, unsigned char *result); +typedef void (*HPMHOOK_post_clif_npc_sell_result) (struct map_session_data *sd, unsigned char result); +typedef void (*HPMHOOK_pre_clif_cashshop_ack) (struct map_session_data **sd, int *error); +typedef void (*HPMHOOK_post_clif_cashshop_ack) (struct map_session_data *sd, int error); +typedef void (*HPMHOOK_pre_clif_scriptmes) (struct map_session_data **sd, int *npcid, const char **mes); +typedef void (*HPMHOOK_post_clif_scriptmes) (struct map_session_data *sd, int npcid, const char *mes); +typedef void (*HPMHOOK_pre_clif_scriptnext) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_scriptnext) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_scriptclose) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_scriptclose) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_scriptmenu) (struct map_session_data **sd, int *npcid, const char **mes); +typedef void (*HPMHOOK_post_clif_scriptmenu) (struct map_session_data *sd, int npcid, const char *mes); +typedef void (*HPMHOOK_pre_clif_scriptinput) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_scriptinput) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_scriptinputstr) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_scriptinputstr) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_cutin) (struct map_session_data **sd, const char **image, int *type); +typedef void (*HPMHOOK_post_clif_cutin) (struct map_session_data *sd, const char *image, int type); +typedef void (*HPMHOOK_pre_clif_sendfakenpc) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_sendfakenpc) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_scriptclear) (struct map_session_data **sd, int *npcid); +typedef void (*HPMHOOK_post_clif_scriptclear) (struct map_session_data *sd, int npcid); +typedef void (*HPMHOOK_pre_clif_viewpoint) (struct map_session_data **sd, int *npc_id, int *type, int *x, int *y, int *id, int *color); +typedef void (*HPMHOOK_post_clif_viewpoint) (struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color); +typedef int (*HPMHOOK_pre_clif_damage) (struct block_list **src, struct block_list **dst, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); +typedef int (*HPMHOOK_post_clif_damage) (int retVal___, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2); +typedef void (*HPMHOOK_pre_clif_sitting) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_sitting) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_standing) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_standing) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_arrow_create_list) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_arrow_create_list) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_refresh_storagewindow) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_refresh_storagewindow) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_refresh) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_refresh) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_fame_blacksmith) (struct map_session_data **sd, int *points); +typedef void (*HPMHOOK_post_clif_fame_blacksmith) (struct map_session_data *sd, int points); +typedef void (*HPMHOOK_pre_clif_fame_alchemist) (struct map_session_data **sd, int *points); +typedef void (*HPMHOOK_post_clif_fame_alchemist) (struct map_session_data *sd, int points); +typedef void (*HPMHOOK_pre_clif_fame_taekwon) (struct map_session_data **sd, int *points); +typedef void (*HPMHOOK_post_clif_fame_taekwon) (struct map_session_data *sd, int points); +typedef void (*HPMHOOK_pre_clif_ranklist) (struct map_session_data **sd, enum fame_list_type *type); +typedef void (*HPMHOOK_post_clif_ranklist) (struct map_session_data *sd, enum fame_list_type type); +typedef void (*HPMHOOK_pre_clif_update_rankingpoint) (struct map_session_data **sd, enum fame_list_type *type, int *points); +typedef void (*HPMHOOK_post_clif_update_rankingpoint) (struct map_session_data *sd, enum fame_list_type type, int points); +typedef void (*HPMHOOK_pre_clif_pRanklist) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRanklist) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_hotkeys) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_hotkeys) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_insight) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_clif_insight) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_clif_outsight) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_clif_outsight) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_clif_skillcastcancel) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_skillcastcancel) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_skill_fail) (struct map_session_data **sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype); +typedef void (*HPMHOOK_post_clif_skill_fail) (struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype); +typedef void (*HPMHOOK_pre_clif_skill_cooldown) (struct map_session_data **sd, uint16 *skill_id, unsigned int *duration); +typedef void (*HPMHOOK_post_clif_skill_cooldown) (struct map_session_data *sd, uint16 skill_id, unsigned int duration); +typedef void (*HPMHOOK_pre_clif_skill_memomessage) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_skill_memomessage) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_skill_mapinfomessage) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_skill_mapinfomessage) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_skill_produce_mix_list) (struct map_session_data **sd, int *skill_id, int *trigger); +typedef void (*HPMHOOK_post_clif_skill_produce_mix_list) (struct map_session_data *sd, int skill_id, int trigger); +typedef void (*HPMHOOK_pre_clif_cooking_list) (struct map_session_data **sd, int *trigger, uint16 *skill_id, int *qty, int *list_type); +typedef void (*HPMHOOK_post_clif_cooking_list) (struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type); +typedef void (*HPMHOOK_pre_clif_autospell) (struct map_session_data **sd, uint16 *skill_lv); +typedef void (*HPMHOOK_post_clif_autospell) (struct map_session_data *sd, uint16 skill_lv); +typedef void (*HPMHOOK_pre_clif_combo_delay) (struct block_list **bl, int *wait); +typedef void (*HPMHOOK_post_clif_combo_delay) (struct block_list *bl, int wait); +typedef void (*HPMHOOK_pre_clif_status_change) (struct block_list **bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3); +typedef void (*HPMHOOK_post_clif_status_change) (struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3); +typedef void (*HPMHOOK_pre_clif_insert_card) (struct map_session_data **sd, int *idx_equip, int *idx_card, int *flag); +typedef void (*HPMHOOK_post_clif_insert_card) (struct map_session_data *sd, int idx_equip, int idx_card, int flag); +typedef void (*HPMHOOK_pre_clif_inventorylist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_inventorylist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_equiplist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_equiplist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_cartlist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_cartlist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_favorite_item) (struct map_session_data **sd, unsigned short *index); +typedef void (*HPMHOOK_post_clif_favorite_item) (struct map_session_data *sd, unsigned short index); +typedef void (*HPMHOOK_pre_clif_clearcart) (int *fd); +typedef void (*HPMHOOK_post_clif_clearcart) (int fd); +typedef void (*HPMHOOK_pre_clif_item_identify_list) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_item_identify_list) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_item_identified) (struct map_session_data **sd, int *idx, int *flag); +typedef void (*HPMHOOK_post_clif_item_identified) (struct map_session_data *sd, int idx, int flag); +typedef void (*HPMHOOK_pre_clif_item_repair_list) (struct map_session_data **sd, struct map_session_data **dstsd, int *lv); +typedef void (*HPMHOOK_post_clif_item_repair_list) (struct map_session_data *sd, struct map_session_data *dstsd, int lv); +typedef void (*HPMHOOK_pre_clif_item_repaireffect) (struct map_session_data **sd, int *idx, int *flag); +typedef void (*HPMHOOK_post_clif_item_repaireffect) (struct map_session_data *sd, int idx, int flag); +typedef void (*HPMHOOK_pre_clif_item_damaged) (struct map_session_data **sd, unsigned short *position); +typedef void (*HPMHOOK_post_clif_item_damaged) (struct map_session_data *sd, unsigned short position); +typedef void (*HPMHOOK_pre_clif_item_refine_list) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_item_refine_list) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_item_skill) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef void (*HPMHOOK_post_clif_item_skill) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef void (*HPMHOOK_pre_clif_mvp_item) (struct map_session_data **sd, int *nameid); +typedef void (*HPMHOOK_post_clif_mvp_item) (struct map_session_data *sd, int nameid); +typedef void (*HPMHOOK_pre_clif_mvp_exp) (struct map_session_data **sd, unsigned int *exp); +typedef void (*HPMHOOK_post_clif_mvp_exp) (struct map_session_data *sd, unsigned int exp); +typedef void (*HPMHOOK_pre_clif_mvp_noitem) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_mvp_noitem) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_changed_dir) (struct block_list **bl, enum send_target *target); +typedef void (*HPMHOOK_post_clif_changed_dir) (struct block_list *bl, enum send_target target); +typedef void (*HPMHOOK_pre_clif_charnameack) (int *fd, struct block_list **bl); +typedef void (*HPMHOOK_post_clif_charnameack) (int fd, struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_monster_hp_bar) (struct mob_data **md, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_monster_hp_bar) (struct mob_data *md, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_hpmeter) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_clif_hpmeter) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_hpmeter_single) (int *fd, int *id, unsigned int *hp, unsigned int *maxhp); +typedef void (*HPMHOOK_post_clif_hpmeter_single) (int fd, int id, unsigned int hp, unsigned int maxhp); +typedef int (*HPMHOOK_pre_clif_hpmeter_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_clif_hpmeter_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_clif_upgrademessage) (int *fd, int *result, int *item_id); +typedef void (*HPMHOOK_post_clif_upgrademessage) (int fd, int result, int item_id); +typedef void (*HPMHOOK_pre_clif_get_weapon_view) (struct map_session_data **sd, unsigned short **rhand, unsigned short **lhand); +typedef void (*HPMHOOK_post_clif_get_weapon_view) (struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand); +typedef void (*HPMHOOK_pre_clif_gospel_info) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_gospel_info) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_feel_req) (int *fd, struct map_session_data **sd, uint16 *skill_lv); +typedef void (*HPMHOOK_post_clif_feel_req) (int fd, struct map_session_data *sd, uint16 skill_lv); +typedef void (*HPMHOOK_pre_clif_starskill) (struct map_session_data **sd, const char **mapname, int *monster_id, unsigned char *star, unsigned char *result); +typedef void (*HPMHOOK_post_clif_starskill) (struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result); +typedef void (*HPMHOOK_pre_clif_feel_info) (struct map_session_data **sd, unsigned char *feel_level, unsigned char *type); +typedef void (*HPMHOOK_post_clif_feel_info) (struct map_session_data *sd, unsigned char feel_level, unsigned char type); +typedef void (*HPMHOOK_pre_clif_hate_info) (struct map_session_data **sd, unsigned char *hate_level, int *class_, unsigned char *type); +typedef void (*HPMHOOK_post_clif_hate_info) (struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type); +typedef void (*HPMHOOK_pre_clif_mission_info) (struct map_session_data **sd, int *mob_id, unsigned char *progress); +typedef void (*HPMHOOK_post_clif_mission_info) (struct map_session_data *sd, int mob_id, unsigned char progress); +typedef void (*HPMHOOK_pre_clif_feel_hate_reset) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_feel_hate_reset) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_partytickack) (struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_clif_partytickack) (struct map_session_data *sd, bool flag); +typedef void (*HPMHOOK_pre_clif_equiptickack) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_equiptickack) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_viewequip_ack) (struct map_session_data **sd, struct map_session_data **tsd); +typedef void (*HPMHOOK_post_clif_viewequip_ack) (struct map_session_data *sd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_clif_equpcheckbox) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_equpcheckbox) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_displayexp) (struct map_session_data **sd, unsigned int *exp, char *type, bool *is_quest); +typedef void (*HPMHOOK_post_clif_displayexp) (struct map_session_data *sd, unsigned int exp, char type, bool is_quest); +typedef void (*HPMHOOK_pre_clif_font) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_font) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_progressbar) (struct map_session_data **sd, unsigned int *color, unsigned int *second); +typedef void (*HPMHOOK_post_clif_progressbar) (struct map_session_data *sd, unsigned int color, unsigned int second); +typedef void (*HPMHOOK_pre_clif_progressbar_abort) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_progressbar_abort) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_showdigit) (struct map_session_data **sd, unsigned char *type, int *value); +typedef void (*HPMHOOK_post_clif_showdigit) (struct map_session_data *sd, unsigned char type, int value); +typedef int (*HPMHOOK_pre_clif_elementalconverter_list) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_clif_elementalconverter_list) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_spellbook_list) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_clif_spellbook_list) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_magicdecoy_list) (struct map_session_data **sd, uint16 *skill_lv, short *x, short *y); +typedef int (*HPMHOOK_post_clif_magicdecoy_list) (int retVal___, struct map_session_data *sd, uint16 skill_lv, short x, short y); +typedef int (*HPMHOOK_pre_clif_poison_list) (struct map_session_data **sd, uint16 *skill_lv); +typedef int (*HPMHOOK_post_clif_poison_list) (int retVal___, struct map_session_data *sd, uint16 skill_lv); +typedef int (*HPMHOOK_pre_clif_autoshadowspell_list) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_clif_autoshadowspell_list) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_skill_itemlistwindow) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_clif_skill_itemlistwindow) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef void (*HPMHOOK_pre_clif_sc_load) (struct block_list **bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3); +typedef void (*HPMHOOK_post_clif_sc_load) (struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3); +typedef void (*HPMHOOK_pre_clif_sc_end) (struct block_list **bl, int *tid, enum send_target *target, int *type); +typedef void (*HPMHOOK_post_clif_sc_end) (struct block_list *bl, int tid, enum send_target target, int type); +typedef void (*HPMHOOK_pre_clif_initialstatus) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_initialstatus) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_cooldown_list) (int *fd, struct skill_cd **cd); +typedef void (*HPMHOOK_post_clif_cooldown_list) (int fd, struct skill_cd *cd); +typedef void (*HPMHOOK_pre_clif_updatestatus) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_updatestatus) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_changestatus) (struct map_session_data **sd, int *type, int *val); +typedef void (*HPMHOOK_post_clif_changestatus) (struct map_session_data *sd, int type, int val); +typedef void (*HPMHOOK_pre_clif_statusupack) (struct map_session_data **sd, int *type, int *ok, int *val); +typedef void (*HPMHOOK_post_clif_statusupack) (struct map_session_data *sd, int type, int ok, int val); +typedef void (*HPMHOOK_pre_clif_movetoattack) (struct map_session_data **sd, struct block_list **bl); +typedef void (*HPMHOOK_post_clif_movetoattack) (struct map_session_data *sd, struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_solved_charname) (int *fd, int *charid, const char **name); +typedef void (*HPMHOOK_post_clif_solved_charname) (int fd, int charid, const char *name); +typedef void (*HPMHOOK_pre_clif_charnameupdate) (struct map_session_data **ssd); +typedef void (*HPMHOOK_post_clif_charnameupdate) (struct map_session_data *ssd); +typedef int (*HPMHOOK_pre_clif_delayquit) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_clif_delayquit) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_clif_getareachar_pc) (struct map_session_data **sd, struct map_session_data **dstsd); +typedef void (*HPMHOOK_post_clif_getareachar_pc) (struct map_session_data *sd, struct map_session_data *dstsd); +typedef void (*HPMHOOK_pre_clif_disconnect_ack) (struct map_session_data **sd, short *result); +typedef void (*HPMHOOK_post_clif_disconnect_ack) (struct map_session_data *sd, short result); +typedef void (*HPMHOOK_pre_clif_PVPInfo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PVPInfo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_blacksmith) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_blacksmith) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_alchemist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_alchemist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_taekwon) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_taekwon) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_ranking_pk) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_ranking_pk) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_quitsave) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_quitsave) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_misceffect) (struct block_list **bl, int *type); +typedef void (*HPMHOOK_post_clif_misceffect) (struct block_list *bl, int type); +typedef void (*HPMHOOK_pre_clif_changeoption) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_changeoption) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_changeoption2) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_changeoption2) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_emotion) (struct block_list **bl, int *type); +typedef void (*HPMHOOK_post_clif_emotion) (struct block_list *bl, int type); +typedef void (*HPMHOOK_pre_clif_talkiebox) (struct block_list **bl, const char **talkie); +typedef void (*HPMHOOK_post_clif_talkiebox) (struct block_list *bl, const char *talkie); +typedef void (*HPMHOOK_pre_clif_wedding_effect) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_wedding_effect) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_divorced) (struct map_session_data **sd, const char **name); +typedef void (*HPMHOOK_post_clif_divorced) (struct map_session_data *sd, const char *name); +typedef void (*HPMHOOK_pre_clif_callpartner) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_callpartner) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_skill_damage) (struct block_list **src, struct block_list **dst, int64 *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type); +typedef int (*HPMHOOK_post_clif_skill_damage) (int retVal___, struct block_list *src, struct block_list *dst, int64 tick, int sdelay, int ddelay, int64 damage, int div, uint16 skill_id, uint16 skill_lv, int type); +typedef int (*HPMHOOK_pre_clif_skill_nodamage) (struct block_list **src, struct block_list **dst, uint16 *skill_id, int *heal, int *fail); +typedef int (*HPMHOOK_post_clif_skill_nodamage) (int retVal___, struct block_list *src, struct block_list *dst, uint16 skill_id, int heal, int fail); +typedef void (*HPMHOOK_pre_clif_skill_poseffect) (struct block_list **src, uint16 *skill_id, int *val, int *x, int *y, int64 *tick); +typedef void (*HPMHOOK_post_clif_skill_poseffect) (struct block_list *src, uint16 skill_id, int val, int x, int y, int64 tick); +typedef void (*HPMHOOK_pre_clif_skill_estimation) (struct map_session_data **sd, struct block_list **dst); +typedef void (*HPMHOOK_post_clif_skill_estimation) (struct map_session_data *sd, struct block_list *dst); +typedef void (*HPMHOOK_pre_clif_skill_warppoint) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4); +typedef void (*HPMHOOK_post_clif_skill_warppoint) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4); +typedef void (*HPMHOOK_pre_clif_skillcasting) (struct block_list **bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime); +typedef void (*HPMHOOK_post_clif_skillcasting) (struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, int property, int casttime); +typedef void (*HPMHOOK_pre_clif_produce_effect) (struct map_session_data **sd, int *flag, int *nameid); +typedef void (*HPMHOOK_post_clif_produce_effect) (struct map_session_data *sd, int flag, int nameid); +typedef void (*HPMHOOK_pre_clif_devotion) (struct block_list **src, struct map_session_data **tsd); +typedef void (*HPMHOOK_post_clif_devotion) (struct block_list *src, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_clif_spiritball) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_spiritball) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_spiritball_single) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_spiritball_single) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_bladestop) (struct block_list **src, int *dst_id, int *active); +typedef void (*HPMHOOK_post_clif_bladestop) (struct block_list *src, int dst_id, int active); +typedef void (*HPMHOOK_pre_clif_mvp_effect) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_mvp_effect) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_heal) (int *fd, int *type, int *val); +typedef void (*HPMHOOK_post_clif_heal) (int fd, int type, int val); +typedef void (*HPMHOOK_pre_clif_resurrection) (struct block_list **bl, int *type); +typedef void (*HPMHOOK_post_clif_resurrection) (struct block_list *bl, int type); +typedef void (*HPMHOOK_pre_clif_refine) (int *fd, int *fail, int *index, int *val); +typedef void (*HPMHOOK_post_clif_refine) (int fd, int fail, int index, int val); +typedef void (*HPMHOOK_pre_clif_weather) (int16 *m); +typedef void (*HPMHOOK_post_clif_weather) (int16 m); +typedef void (*HPMHOOK_pre_clif_specialeffect) (struct block_list **bl, int *type, enum send_target *target); +typedef void (*HPMHOOK_post_clif_specialeffect) (struct block_list *bl, int type, enum send_target target); +typedef void (*HPMHOOK_pre_clif_specialeffect_single) (struct block_list **bl, int *type, int *fd); +typedef void (*HPMHOOK_post_clif_specialeffect_single) (struct block_list *bl, int type, int fd); +typedef void (*HPMHOOK_pre_clif_specialeffect_value) (struct block_list **bl, int *effect_id, int *num, send_target *target); +typedef void (*HPMHOOK_post_clif_specialeffect_value) (struct block_list *bl, int effect_id, int num, send_target target); +typedef void (*HPMHOOK_pre_clif_millenniumshield) (struct block_list **bl, short *shields); +typedef void (*HPMHOOK_post_clif_millenniumshield) (struct block_list *bl, short shields); +typedef void (*HPMHOOK_pre_clif_spiritcharm) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_spiritcharm) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_charm_single) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_charm_single) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_snap) (struct block_list **bl, short *x, short *y); +typedef void (*HPMHOOK_post_clif_snap) (struct block_list *bl, short x, short y); +typedef void (*HPMHOOK_pre_clif_weather_check) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_weather_check) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_playBGM) (struct map_session_data **sd, const char **name); +typedef void (*HPMHOOK_post_clif_playBGM) (struct map_session_data *sd, const char *name); +typedef void (*HPMHOOK_pre_clif_soundeffect) (struct map_session_data **sd, struct block_list **bl, const char **name, int *type); +typedef void (*HPMHOOK_post_clif_soundeffect) (struct map_session_data *sd, struct block_list *bl, const char *name, int type); +typedef void (*HPMHOOK_pre_clif_soundeffectall) (struct block_list **bl, const char **name, int *type, enum send_target *coverage); +typedef void (*HPMHOOK_post_clif_soundeffectall) (struct block_list *bl, const char *name, int type, enum send_target coverage); +typedef void (*HPMHOOK_pre_clif_GlobalMessage) (struct block_list **bl, const char **message); +typedef void (*HPMHOOK_post_clif_GlobalMessage) (struct block_list *bl, const char *message); +typedef void (*HPMHOOK_pre_clif_createchat) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_createchat) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_dispchat) (struct chat_data **cd, int *fd); +typedef void (*HPMHOOK_post_clif_dispchat) (struct chat_data *cd, int fd); +typedef void (*HPMHOOK_pre_clif_joinchatfail) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_joinchatfail) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_joinchatok) (struct map_session_data **sd, struct chat_data **cd); +typedef void (*HPMHOOK_post_clif_joinchatok) (struct map_session_data *sd, struct chat_data *cd); +typedef void (*HPMHOOK_pre_clif_addchat) (struct chat_data **cd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_addchat) (struct chat_data *cd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_changechatowner) (struct chat_data **cd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_changechatowner) (struct chat_data *cd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_clearchat) (struct chat_data **cd, int *fd); +typedef void (*HPMHOOK_post_clif_clearchat) (struct chat_data *cd, int fd); +typedef void (*HPMHOOK_pre_clif_leavechat) (struct chat_data **cd, struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_clif_leavechat) (struct chat_data *cd, struct map_session_data *sd, bool flag); +typedef void (*HPMHOOK_pre_clif_changechatstatus) (struct chat_data **cd); +typedef void (*HPMHOOK_post_clif_changechatstatus) (struct chat_data *cd); +typedef void (*HPMHOOK_pre_clif_wis_message) (int *fd, const char **nick, const char **mes, int *mes_len); +typedef void (*HPMHOOK_post_clif_wis_message) (int fd, const char *nick, const char *mes, int mes_len); +typedef void (*HPMHOOK_pre_clif_wis_end) (int *fd, int *flag); +typedef void (*HPMHOOK_post_clif_wis_end) (int fd, int flag); +typedef void (*HPMHOOK_pre_clif_disp_message) (struct block_list **src, const char **mes, enum send_target *target); +typedef void (*HPMHOOK_post_clif_disp_message) (struct block_list *src, const char *mes, enum send_target target); +typedef void (*HPMHOOK_pre_clif_broadcast) (struct block_list **bl, const char **mes, int *len, int *type, enum send_target *target); +typedef void (*HPMHOOK_post_clif_broadcast) (struct block_list *bl, const char *mes, int len, int type, enum send_target target); +typedef void (*HPMHOOK_pre_clif_broadcast2) (struct block_list **bl, const char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target); +typedef void (*HPMHOOK_post_clif_broadcast2) (struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target); +typedef void (*HPMHOOK_pre_clif_messagecolor_self) (int *fd, uint32 *color, const char **msg); +typedef void (*HPMHOOK_post_clif_messagecolor_self) (int fd, uint32 color, const char *msg); +typedef void (*HPMHOOK_pre_clif_messagecolor) (struct block_list **bl, uint32 *color, const char **msg); +typedef void (*HPMHOOK_post_clif_messagecolor) (struct block_list *bl, uint32 color, const char *msg); +typedef void (*HPMHOOK_pre_clif_disp_overhead) (struct block_list **bl, const char **mes); +typedef void (*HPMHOOK_post_clif_disp_overhead) (struct block_list *bl, const char *mes); +typedef void (*HPMHOOK_pre_clif_msgtable) (struct map_session_data **sd, unsigned short *msg_id); +typedef void (*HPMHOOK_post_clif_msgtable) (struct map_session_data *sd, unsigned short msg_id); +typedef void (*HPMHOOK_pre_clif_msgtable_num) (struct map_session_data **sd, unsigned short *msg_id, int *value); +typedef void (*HPMHOOK_post_clif_msgtable_num) (struct map_session_data *sd, unsigned short msg_id, int value); +typedef void (*HPMHOOK_pre_clif_msgtable_skill) (struct map_session_data **sd, uint16 *skill_id, int *msg_id); +typedef void (*HPMHOOK_post_clif_msgtable_skill) (struct map_session_data *sd, uint16 skill_id, int msg_id); +typedef void (*HPMHOOK_pre_clif_message) (const int *fd, const char **mes); +typedef void (*HPMHOOK_post_clif_message) (const int fd, const char *mes); +typedef void (*HPMHOOK_pre_clif_messageln) (const int *fd, const char **mes); +typedef void (*HPMHOOK_post_clif_messageln) (const int fd, const char *mes); +typedef const char* (*HPMHOOK_pre_clif_process_chat_message) (struct map_session_data **sd, const struct packet_chat_message **packet, char **out_buf, int *out_buflen); +typedef const char* (*HPMHOOK_post_clif_process_chat_message) (const char* retVal___, struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen); +typedef bool (*HPMHOOK_pre_clif_process_whisper_message) (struct map_session_data **sd, const struct packet_whisper_message **packet, char **out_name, char **out_message, int *out_messagelen); +typedef bool (*HPMHOOK_post_clif_process_whisper_message) (bool retVal___, struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen); +typedef void (*HPMHOOK_pre_clif_wisexin) (struct map_session_data **sd, int *type, int *flag); +typedef void (*HPMHOOK_post_clif_wisexin) (struct map_session_data *sd, int type, int flag); +typedef void (*HPMHOOK_pre_clif_wisall) (struct map_session_data **sd, int *type, int *flag); +typedef void (*HPMHOOK_post_clif_wisall) (struct map_session_data *sd, int type, int flag); +typedef void (*HPMHOOK_pre_clif_PMIgnoreList) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PMIgnoreList) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_ShowScript) (struct block_list **bl, const char **message); +typedef void (*HPMHOOK_post_clif_ShowScript) (struct block_list *bl, const char *message); +typedef void (*HPMHOOK_pre_clif_traderequest) (struct map_session_data **sd, const char **name); +typedef void (*HPMHOOK_post_clif_traderequest) (struct map_session_data *sd, const char *name); +typedef void (*HPMHOOK_pre_clif_tradestart) (struct map_session_data **sd, uint8 *type); +typedef void (*HPMHOOK_post_clif_tradestart) (struct map_session_data *sd, uint8 type); +typedef void (*HPMHOOK_pre_clif_tradeadditem) (struct map_session_data **sd, struct map_session_data **tsd, int *index, int *amount); +typedef void (*HPMHOOK_post_clif_tradeadditem) (struct map_session_data *sd, struct map_session_data *tsd, int index, int amount); +typedef void (*HPMHOOK_pre_clif_tradeitemok) (struct map_session_data **sd, int *index, int *fail); +typedef void (*HPMHOOK_post_clif_tradeitemok) (struct map_session_data *sd, int index, int fail); +typedef void (*HPMHOOK_pre_clif_tradedeal_lock) (struct map_session_data **sd, int *fail); +typedef void (*HPMHOOK_post_clif_tradedeal_lock) (struct map_session_data *sd, int fail); +typedef void (*HPMHOOK_pre_clif_tradecancelled) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_tradecancelled) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_tradecompleted) (struct map_session_data **sd, int *fail); +typedef void (*HPMHOOK_post_clif_tradecompleted) (struct map_session_data *sd, int fail); +typedef void (*HPMHOOK_pre_clif_tradeundo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_tradeundo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_openvendingreq) (struct map_session_data **sd, int *num); +typedef void (*HPMHOOK_post_clif_openvendingreq) (struct map_session_data *sd, int num); +typedef void (*HPMHOOK_pre_clif_showvendingboard) (struct block_list **bl, const char **message, int *fd); +typedef void (*HPMHOOK_post_clif_showvendingboard) (struct block_list *bl, const char *message, int fd); +typedef void (*HPMHOOK_pre_clif_closevendingboard) (struct block_list **bl, int *fd); +typedef void (*HPMHOOK_post_clif_closevendingboard) (struct block_list *bl, int fd); +typedef void (*HPMHOOK_pre_clif_vendinglist) (struct map_session_data **sd, unsigned int *id, struct s_vending **vending_list); +typedef void (*HPMHOOK_post_clif_vendinglist) (struct map_session_data *sd, unsigned int id, struct s_vending *vending_list); +typedef void (*HPMHOOK_pre_clif_buyvending) (struct map_session_data **sd, int *index, int *amount, int *fail); +typedef void (*HPMHOOK_post_clif_buyvending) (struct map_session_data *sd, int index, int amount, int fail); +typedef void (*HPMHOOK_pre_clif_openvending) (struct map_session_data **sd, int *id, struct s_vending **vending_list); +typedef void (*HPMHOOK_post_clif_openvending) (struct map_session_data *sd, int id, struct s_vending *vending_list); +typedef void (*HPMHOOK_pre_clif_vendingreport) (struct map_session_data **sd, int *index, int *amount); +typedef void (*HPMHOOK_post_clif_vendingreport) (struct map_session_data *sd, int index, int amount); +typedef void (*HPMHOOK_pre_clif_storagelist) (struct map_session_data **sd, struct item **items, int *items_length); +typedef void (*HPMHOOK_post_clif_storagelist) (struct map_session_data *sd, struct item *items, int items_length); +typedef void (*HPMHOOK_pre_clif_updatestorageamount) (struct map_session_data **sd, int *amount, int *max_amount); +typedef void (*HPMHOOK_post_clif_updatestorageamount) (struct map_session_data *sd, int amount, int max_amount); +typedef void (*HPMHOOK_pre_clif_storageitemadded) (struct map_session_data **sd, struct item **i, int *index, int *amount); +typedef void (*HPMHOOK_post_clif_storageitemadded) (struct map_session_data *sd, struct item *i, int index, int amount); +typedef void (*HPMHOOK_pre_clif_storageitemremoved) (struct map_session_data **sd, int *index, int *amount); +typedef void (*HPMHOOK_post_clif_storageitemremoved) (struct map_session_data *sd, int index, int amount); +typedef void (*HPMHOOK_pre_clif_storageclose) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_storageclose) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_skillinfoblock) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_skillinfoblock) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_skillup) (struct map_session_data **sd, uint16 *skill_id, int *skill_lv, int *flag); +typedef void (*HPMHOOK_post_clif_skillup) (struct map_session_data *sd, uint16 skill_id, int skill_lv, int flag); +typedef void (*HPMHOOK_pre_clif_skillinfo) (struct map_session_data **sd, int *skill_id, int *inf); +typedef void (*HPMHOOK_post_clif_skillinfo) (struct map_session_data *sd, int skill_id, int inf); +typedef void (*HPMHOOK_pre_clif_addskill) (struct map_session_data **sd, int *id); +typedef void (*HPMHOOK_post_clif_addskill) (struct map_session_data *sd, int id); +typedef void (*HPMHOOK_pre_clif_deleteskill) (struct map_session_data **sd, int *id); +typedef void (*HPMHOOK_post_clif_deleteskill) (struct map_session_data *sd, int id); +typedef void (*HPMHOOK_pre_clif_party_created) (struct map_session_data **sd, int *result); +typedef void (*HPMHOOK_post_clif_party_created) (struct map_session_data *sd, int result); +typedef void (*HPMHOOK_pre_clif_party_member_info) (struct party_data **p, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_member_info) (struct party_data *p, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_info) (struct party_data **p, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_info) (struct party_data *p, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_invite) (struct map_session_data **sd, struct map_session_data **tsd); +typedef void (*HPMHOOK_post_clif_party_invite) (struct map_session_data *sd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_clif_party_inviteack) (struct map_session_data **sd, const char **nick, int *result); +typedef void (*HPMHOOK_post_clif_party_inviteack) (struct map_session_data *sd, const char *nick, int result); +typedef void (*HPMHOOK_pre_clif_party_option) (struct party_data **p, struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_party_option) (struct party_data *p, struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_party_withdraw) (struct party_data **p, struct map_session_data **sd, int *account_id, const char **name, int *flag); +typedef void (*HPMHOOK_post_clif_party_withdraw) (struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag); +typedef void (*HPMHOOK_pre_clif_party_message) (struct party_data **p, int *account_id, const char **mes, int *len); +typedef void (*HPMHOOK_post_clif_party_message) (struct party_data *p, int account_id, const char *mes, int len); +typedef void (*HPMHOOK_pre_clif_party_xy) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_xy) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_xy_single) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_xy_single) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_hp) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_hp) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_xy_remove) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_party_xy_remove) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_party_show_picker) (struct map_session_data **sd, struct item **item_data); +typedef void (*HPMHOOK_post_clif_party_show_picker) (struct map_session_data *sd, struct item *item_data); +typedef void (*HPMHOOK_pre_clif_partyinvitationstate) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_partyinvitationstate) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_PartyLeaderChanged) (struct map_session_data **sd, int *prev_leader_aid, int *new_leader_aid); +typedef void (*HPMHOOK_post_clif_PartyLeaderChanged) (struct map_session_data *sd, int prev_leader_aid, int new_leader_aid); +typedef void (*HPMHOOK_pre_clif_guild_created) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_guild_created) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_guild_belonginfo) (struct map_session_data **sd, struct guild **g); +typedef void (*HPMHOOK_post_clif_guild_belonginfo) (struct map_session_data *sd, struct guild *g); +typedef void (*HPMHOOK_pre_clif_guild_masterormember) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_masterormember) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_basicinfo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_basicinfo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_allianceinfo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_allianceinfo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_memberlist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_memberlist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_skillinfo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_skillinfo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_send_onlineinfo) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_send_onlineinfo) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_memberlogin_notice) (struct guild **g, int *idx, int *flag); +typedef void (*HPMHOOK_post_clif_guild_memberlogin_notice) (struct guild *g, int idx, int flag); +typedef void (*HPMHOOK_pre_clif_guild_invite) (struct map_session_data **sd, struct guild **g); +typedef void (*HPMHOOK_post_clif_guild_invite) (struct map_session_data *sd, struct guild *g); +typedef void (*HPMHOOK_pre_clif_guild_inviteack) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_guild_inviteack) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_guild_leave) (struct map_session_data **sd, const char **name, const char **mes); +typedef void (*HPMHOOK_post_clif_guild_leave) (struct map_session_data *sd, const char *name, const char *mes); +typedef void (*HPMHOOK_pre_clif_guild_expulsion) (struct map_session_data **sd, const char **name, const char **mes, int *account_id); +typedef void (*HPMHOOK_post_clif_guild_expulsion) (struct map_session_data *sd, const char *name, const char *mes, int account_id); +typedef void (*HPMHOOK_pre_clif_guild_positionchanged) (struct guild **g, int *idx); +typedef void (*HPMHOOK_post_clif_guild_positionchanged) (struct guild *g, int idx); +typedef void (*HPMHOOK_pre_clif_guild_memberpositionchanged) (struct guild **g, int *idx); +typedef void (*HPMHOOK_post_clif_guild_memberpositionchanged) (struct guild *g, int idx); +typedef void (*HPMHOOK_pre_clif_guild_emblem) (struct map_session_data **sd, struct guild **g); +typedef void (*HPMHOOK_post_clif_guild_emblem) (struct map_session_data *sd, struct guild *g); +typedef void (*HPMHOOK_pre_clif_guild_emblem_area) (struct block_list **bl); +typedef void (*HPMHOOK_post_clif_guild_emblem_area) (struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_guild_notice) (struct map_session_data **sd, struct guild **g); +typedef void (*HPMHOOK_post_clif_guild_notice) (struct map_session_data *sd, struct guild *g); +typedef void (*HPMHOOK_pre_clif_guild_message) (struct guild **g, int *account_id, const char **mes, int *len); +typedef void (*HPMHOOK_post_clif_guild_message) (struct guild *g, int account_id, const char *mes, int len); +typedef void (*HPMHOOK_pre_clif_guild_reqalliance) (struct map_session_data **sd, int *account_id, const char **name); +typedef void (*HPMHOOK_post_clif_guild_reqalliance) (struct map_session_data *sd, int account_id, const char *name); +typedef void (*HPMHOOK_pre_clif_guild_allianceack) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_guild_allianceack) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_guild_delalliance) (struct map_session_data **sd, int *guild_id, int *flag); +typedef void (*HPMHOOK_post_clif_guild_delalliance) (struct map_session_data *sd, int guild_id, int flag); +typedef void (*HPMHOOK_pre_clif_guild_oppositionack) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_guild_oppositionack) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_guild_broken) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_guild_broken) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_guild_xy) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_xy) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_xy_single) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_xy_single) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_xy_remove) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_xy_remove) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_positionnamelist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_positionnamelist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_positioninfolist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_positioninfolist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_guild_expulsionlist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_guild_expulsionlist) (struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_clif_validate_emblem) (const uint8 **emblem, unsigned long *emblem_len); +typedef bool (*HPMHOOK_post_clif_validate_emblem) (bool retVal___, const uint8 *emblem, unsigned long emblem_len); +typedef void (*HPMHOOK_pre_clif_bg_hp) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_bg_hp) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_bg_xy) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_bg_xy) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_bg_xy_remove) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_bg_xy_remove) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_bg_message) (struct battleground_data **bgd, int *src_id, const char **name, const char **mes); +typedef void (*HPMHOOK_post_clif_bg_message) (struct battleground_data *bgd, int src_id, const char *name, const char *mes); +typedef void (*HPMHOOK_pre_clif_bg_updatescore) (int16 *m); +typedef void (*HPMHOOK_post_clif_bg_updatescore) (int16 m); +typedef void (*HPMHOOK_pre_clif_bg_updatescore_single) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_bg_updatescore_single) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_sendbgemblem_area) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_sendbgemblem_area) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_sendbgemblem_single) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_sendbgemblem_single) (int fd, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_instance) (int *instance_id, int *type, int *flag); +typedef int (*HPMHOOK_post_clif_instance) (int retVal___, int instance_id, int type, int flag); +typedef void (*HPMHOOK_pre_clif_instance_join) (int *fd, int *instance_id); +typedef void (*HPMHOOK_post_clif_instance_join) (int fd, int instance_id); +typedef void (*HPMHOOK_pre_clif_instance_leave) (int *fd); +typedef void (*HPMHOOK_post_clif_instance_leave) (int fd); +typedef void (*HPMHOOK_pre_clif_catch_process) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_catch_process) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pet_roulette) (struct map_session_data **sd, int *data); +typedef void (*HPMHOOK_post_clif_pet_roulette) (struct map_session_data *sd, int data); +typedef void (*HPMHOOK_pre_clif_sendegg) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_sendegg) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_send_petstatus) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_send_petstatus) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_send_petdata) (struct map_session_data **sd, struct pet_data **pd, int *type, int *param); +typedef void (*HPMHOOK_post_clif_send_petdata) (struct map_session_data *sd, struct pet_data *pd, int type, int param); +typedef void (*HPMHOOK_pre_clif_pet_emotion) (struct pet_data **pd, int *param); +typedef void (*HPMHOOK_post_clif_pet_emotion) (struct pet_data *pd, int param); +typedef void (*HPMHOOK_pre_clif_pet_food) (struct map_session_data **sd, int *foodid, int *fail); +typedef void (*HPMHOOK_post_clif_pet_food) (struct map_session_data *sd, int foodid, int fail); +typedef int (*HPMHOOK_pre_clif_friendslist_toggle_sub) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_clif_friendslist_toggle_sub) (int retVal___, struct map_session_data *sd, va_list ap); +typedef void (*HPMHOOK_pre_clif_friendslist_send) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_friendslist_send) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_friendslist_reqack) (struct map_session_data **sd, struct map_session_data **f_sd, int *type); +typedef void (*HPMHOOK_post_clif_friendslist_reqack) (struct map_session_data *sd, struct map_session_data *f_sd, int type); +typedef void (*HPMHOOK_pre_clif_friendslist_toggle) (struct map_session_data **sd, int *account_id, int *char_id, int *online); +typedef void (*HPMHOOK_post_clif_friendslist_toggle) (struct map_session_data *sd, int account_id, int char_id, int online); +typedef void (*HPMHOOK_pre_clif_friendlist_req) (struct map_session_data **sd, int *account_id, int *char_id, const char **name); +typedef void (*HPMHOOK_post_clif_friendlist_req) (struct map_session_data *sd, int account_id, int char_id, const char *name); +typedef void (*HPMHOOK_pre_clif_GM_kickack) (struct map_session_data **sd, int *result); +typedef void (*HPMHOOK_post_clif_GM_kickack) (struct map_session_data *sd, int result); +typedef void (*HPMHOOK_pre_clif_GM_kick) (struct map_session_data **sd, struct map_session_data **tsd); +typedef void (*HPMHOOK_post_clif_GM_kick) (struct map_session_data *sd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_clif_manner_message) (struct map_session_data **sd, uint32 *type); +typedef void (*HPMHOOK_post_clif_manner_message) (struct map_session_data *sd, uint32 type); +typedef void (*HPMHOOK_pre_clif_GM_silence) (struct map_session_data **sd, struct map_session_data **tsd, uint8 *type); +typedef void (*HPMHOOK_post_clif_GM_silence) (struct map_session_data *sd, struct map_session_data *tsd, uint8 type); +typedef void (*HPMHOOK_pre_clif_account_name) (struct map_session_data **sd, int *account_id, const char **accname); +typedef void (*HPMHOOK_post_clif_account_name) (struct map_session_data *sd, int account_id, const char *accname); +typedef void (*HPMHOOK_pre_clif_check) (int *fd, struct map_session_data **pl_sd); +typedef void (*HPMHOOK_post_clif_check) (int fd, struct map_session_data *pl_sd); +typedef void (*HPMHOOK_pre_clif_hominfo) (struct map_session_data **sd, struct homun_data **hd, int *flag); +typedef void (*HPMHOOK_post_clif_hominfo) (struct map_session_data *sd, struct homun_data *hd, int flag); +typedef void (*HPMHOOK_pre_clif_homskillinfoblock) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_homskillinfoblock) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_homskillup) (struct map_session_data **sd, uint16 *skill_id); +typedef void (*HPMHOOK_post_clif_homskillup) (struct map_session_data *sd, uint16 skill_id); +typedef void (*HPMHOOK_pre_clif_hom_food) (struct map_session_data **sd, int *foodid, int *fail); +typedef void (*HPMHOOK_post_clif_hom_food) (struct map_session_data *sd, int foodid, int fail); +typedef void (*HPMHOOK_pre_clif_send_homdata) (struct map_session_data **sd, int *state, int *param); +typedef void (*HPMHOOK_post_clif_send_homdata) (struct map_session_data *sd, int state, int param); +typedef void (*HPMHOOK_pre_clif_quest_send_list) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_quest_send_list) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_quest_send_mission) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_quest_send_mission) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_quest_add) (struct map_session_data **sd, struct quest **qd); +typedef void (*HPMHOOK_post_clif_quest_add) (struct map_session_data *sd, struct quest *qd); +typedef void (*HPMHOOK_pre_clif_quest_delete) (struct map_session_data **sd, int *quest_id); +typedef void (*HPMHOOK_post_clif_quest_delete) (struct map_session_data *sd, int quest_id); +typedef void (*HPMHOOK_pre_clif_quest_update_status) (struct map_session_data **sd, int *quest_id, bool *active); +typedef void (*HPMHOOK_post_clif_quest_update_status) (struct map_session_data *sd, int quest_id, bool active); +typedef void (*HPMHOOK_pre_clif_quest_update_objective) (struct map_session_data **sd, struct quest **qd); +typedef void (*HPMHOOK_post_clif_quest_update_objective) (struct map_session_data *sd, struct quest *qd); +typedef void (*HPMHOOK_pre_clif_quest_show_event) (struct map_session_data **sd, struct block_list **bl, short *state, short *color); +typedef void (*HPMHOOK_post_clif_quest_show_event) (struct map_session_data *sd, struct block_list *bl, short state, short color); +typedef void (*HPMHOOK_pre_clif_mail_window) (int *fd, int *flag); +typedef void (*HPMHOOK_post_clif_mail_window) (int fd, int flag); +typedef void (*HPMHOOK_pre_clif_mail_read) (struct map_session_data **sd, int *mail_id); +typedef void (*HPMHOOK_post_clif_mail_read) (struct map_session_data *sd, int mail_id); +typedef void (*HPMHOOK_pre_clif_mail_delete) (int *fd, int *mail_id, short *fail); +typedef void (*HPMHOOK_post_clif_mail_delete) (int fd, int mail_id, short fail); +typedef void (*HPMHOOK_pre_clif_mail_return) (int *fd, int *mail_id, short *fail); +typedef void (*HPMHOOK_post_clif_mail_return) (int fd, int mail_id, short fail); +typedef void (*HPMHOOK_pre_clif_mail_send) (int *fd, bool *fail); +typedef void (*HPMHOOK_post_clif_mail_send) (int fd, bool fail); +typedef void (*HPMHOOK_pre_clif_mail_new) (int *fd, int *mail_id, const char **sender, const char **title); +typedef void (*HPMHOOK_post_clif_mail_new) (int fd, int mail_id, const char *sender, const char *title); +typedef void (*HPMHOOK_pre_clif_mail_refreshinbox) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_mail_refreshinbox) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_mail_getattachment) (int *fd, uint8 *flag); +typedef void (*HPMHOOK_post_clif_mail_getattachment) (int fd, uint8 flag); +typedef void (*HPMHOOK_pre_clif_mail_setattachment) (int *fd, int *index, uint8 *flag); +typedef void (*HPMHOOK_post_clif_mail_setattachment) (int fd, int index, uint8 flag); +typedef void (*HPMHOOK_pre_clif_auction_openwindow) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_auction_openwindow) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_auction_results) (struct map_session_data **sd, short *count, short *pages, const uint8 **buf); +typedef void (*HPMHOOK_post_clif_auction_results) (struct map_session_data *sd, short count, short pages, const uint8 *buf); +typedef void (*HPMHOOK_pre_clif_auction_message) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_clif_auction_message) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_clif_auction_close) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_clif_auction_close) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_clif_auction_setitem) (int *fd, int *index, bool *fail); +typedef void (*HPMHOOK_post_clif_auction_setitem) (int fd, int index, bool fail); +typedef void (*HPMHOOK_pre_clif_mercenary_info) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_mercenary_info) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_mercenary_skillblock) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_mercenary_skillblock) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_mercenary_message) (struct map_session_data **sd, int *message); +typedef void (*HPMHOOK_post_clif_mercenary_message) (struct map_session_data *sd, int message); +typedef void (*HPMHOOK_pre_clif_mercenary_updatestatus) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_mercenary_updatestatus) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_rental_time) (int *fd, int *nameid, int *seconds); +typedef void (*HPMHOOK_post_clif_rental_time) (int fd, int nameid, int seconds); +typedef void (*HPMHOOK_pre_clif_rental_expired) (int *fd, int *index, int *nameid); +typedef void (*HPMHOOK_post_clif_rental_expired) (int fd, int index, int nameid); +typedef void (*HPMHOOK_pre_clif_PartyBookingRegisterAck) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_PartyBookingRegisterAck) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_PartyBookingDeleteAck) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_PartyBookingDeleteAck) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_PartyBookingSearchAck) (int *fd, struct party_booking_ad_info ***results, int *count, bool *more_result); +typedef void (*HPMHOOK_post_clif_PartyBookingSearchAck) (int fd, struct party_booking_ad_info **results, int count, bool more_result); +typedef void (*HPMHOOK_pre_clif_PartyBookingUpdateNotify) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); +typedef void (*HPMHOOK_post_clif_PartyBookingUpdateNotify) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); +typedef void (*HPMHOOK_pre_clif_PartyBookingDeleteNotify) (struct map_session_data **sd, int *index); +typedef void (*HPMHOOK_post_clif_PartyBookingDeleteNotify) (struct map_session_data *sd, int index); +typedef void (*HPMHOOK_pre_clif_PartyBookingInsertNotify) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); +typedef void (*HPMHOOK_post_clif_PartyBookingInsertNotify) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); +typedef void (*HPMHOOK_pre_clif_PartyRecruitRegisterAck) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_PartyRecruitRegisterAck) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_PartyRecruitDeleteAck) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_clif_PartyRecruitDeleteAck) (struct map_session_data *sd, int flag); +typedef void (*HPMHOOK_pre_clif_PartyRecruitSearchAck) (int *fd, struct party_booking_ad_info ***results, int *count, bool *more_result); +typedef void (*HPMHOOK_post_clif_PartyRecruitSearchAck) (int fd, struct party_booking_ad_info **results, int count, bool more_result); +typedef void (*HPMHOOK_pre_clif_PartyRecruitUpdateNotify) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); +typedef void (*HPMHOOK_post_clif_PartyRecruitUpdateNotify) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); +typedef void (*HPMHOOK_pre_clif_PartyRecruitDeleteNotify) (struct map_session_data **sd, int *index); +typedef void (*HPMHOOK_post_clif_PartyRecruitDeleteNotify) (struct map_session_data *sd, int index); +typedef void (*HPMHOOK_pre_clif_PartyRecruitInsertNotify) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); +typedef void (*HPMHOOK_post_clif_PartyRecruitInsertNotify) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); +typedef void (*HPMHOOK_pre_clif_PartyBookingVolunteerInfo) (int *index, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PartyBookingVolunteerInfo) (int index, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_PartyBookingRefuseVolunteer) (unsigned int *aid, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PartyBookingRefuseVolunteer) (unsigned int aid, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_PartyBookingCancelVolunteer) (int *index, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PartyBookingCancelVolunteer) (int index, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_PartyBookingAddFilteringList) (int *index, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PartyBookingAddFilteringList) (int index, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_PartyBookingSubFilteringList) (int *gid, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_PartyBookingSubFilteringList) (int gid, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_open) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_buyingstore_open) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_open_failed) (struct map_session_data **sd, unsigned short *result, unsigned int *weight); +typedef void (*HPMHOOK_post_clif_buyingstore_open_failed) (struct map_session_data *sd, unsigned short result, unsigned int weight); +typedef void (*HPMHOOK_pre_clif_buyingstore_myitemlist) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_buyingstore_myitemlist) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_entry) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_buyingstore_entry) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_entry_single) (struct map_session_data **sd, struct map_session_data **pl_sd); +typedef void (*HPMHOOK_post_clif_buyingstore_entry_single) (struct map_session_data *sd, struct map_session_data *pl_sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_disappear_entry) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_buyingstore_disappear_entry) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_disappear_entry_single) (struct map_session_data **sd, struct map_session_data **pl_sd); +typedef void (*HPMHOOK_post_clif_buyingstore_disappear_entry_single) (struct map_session_data *sd, struct map_session_data *pl_sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_itemlist) (struct map_session_data **sd, struct map_session_data **pl_sd); +typedef void (*HPMHOOK_post_clif_buyingstore_itemlist) (struct map_session_data *sd, struct map_session_data *pl_sd); +typedef void (*HPMHOOK_pre_clif_buyingstore_trade_failed_buyer) (struct map_session_data **sd, short *result); +typedef void (*HPMHOOK_post_clif_buyingstore_trade_failed_buyer) (struct map_session_data *sd, short result); +typedef void (*HPMHOOK_pre_clif_buyingstore_update_item) (struct map_session_data **sd, unsigned short *nameid, unsigned short *amount); +typedef void (*HPMHOOK_post_clif_buyingstore_update_item) (struct map_session_data *sd, unsigned short nameid, unsigned short amount); +typedef void (*HPMHOOK_pre_clif_buyingstore_delete_item) (struct map_session_data **sd, short *index, unsigned short *amount, int *price); +typedef void (*HPMHOOK_post_clif_buyingstore_delete_item) (struct map_session_data *sd, short index, unsigned short amount, int price); +typedef void (*HPMHOOK_pre_clif_buyingstore_trade_failed_seller) (struct map_session_data **sd, short *result, unsigned short *nameid); +typedef void (*HPMHOOK_post_clif_buyingstore_trade_failed_seller) (struct map_session_data *sd, short result, unsigned short nameid); +typedef void (*HPMHOOK_pre_clif_search_store_info_ack) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_search_store_info_ack) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_search_store_info_failed) (struct map_session_data **sd, unsigned char *reason); +typedef void (*HPMHOOK_post_clif_search_store_info_failed) (struct map_session_data *sd, unsigned char reason); +typedef void (*HPMHOOK_pre_clif_open_search_store_info) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_open_search_store_info) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_search_store_info_click_ack) (struct map_session_data **sd, short *x, short *y); +typedef void (*HPMHOOK_post_clif_search_store_info_click_ack) (struct map_session_data *sd, short x, short y); +typedef void (*HPMHOOK_pre_clif_elemental_info) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_elemental_info) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_elemental_updatestatus) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_elemental_updatestatus) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_bgqueue_ack) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id); +typedef void (*HPMHOOK_post_clif_bgqueue_ack) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id); +typedef void (*HPMHOOK_pre_clif_bgqueue_notice_delete) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, const char **name); +typedef void (*HPMHOOK_post_clif_bgqueue_notice_delete) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, const char *name); +typedef void (*HPMHOOK_pre_clif_bgqueue_update_info) (struct map_session_data **sd, unsigned char *arena_id, int *position); +typedef void (*HPMHOOK_post_clif_bgqueue_update_info) (struct map_session_data *sd, unsigned char arena_id, int position); +typedef void (*HPMHOOK_pre_clif_bgqueue_joined) (struct map_session_data **sd, int *pos); +typedef void (*HPMHOOK_post_clif_bgqueue_joined) (struct map_session_data *sd, int pos); +typedef void (*HPMHOOK_pre_clif_bgqueue_pcleft) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_bgqueue_pcleft) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_bgqueue_battlebegins) (struct map_session_data **sd, unsigned char *arena_id, enum send_target *target); +typedef void (*HPMHOOK_post_clif_bgqueue_battlebegins) (struct map_session_data *sd, unsigned char arena_id, enum send_target target); +typedef void (*HPMHOOK_pre_clif_adopt_reply) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_clif_adopt_reply) (struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_clif_adopt_request) (struct map_session_data **sd, struct map_session_data **src, int *p_id); +typedef void (*HPMHOOK_post_clif_adopt_request) (struct map_session_data *sd, struct map_session_data *src, int p_id); +typedef void (*HPMHOOK_pre_clif_readbook) (int *fd, int *book_id, int *page); +typedef void (*HPMHOOK_post_clif_readbook) (int fd, int book_id, int page); +typedef void (*HPMHOOK_pre_clif_notify_time) (struct map_session_data **sd, int64 *time); +typedef void (*HPMHOOK_post_clif_notify_time) (struct map_session_data *sd, int64 time); +typedef void (*HPMHOOK_pre_clif_user_count) (struct map_session_data **sd, int *count); +typedef void (*HPMHOOK_post_clif_user_count) (struct map_session_data *sd, int count); +typedef void (*HPMHOOK_pre_clif_noask_sub) (struct map_session_data **src, struct map_session_data **target, int *type); +typedef void (*HPMHOOK_post_clif_noask_sub) (struct map_session_data *src, struct map_session_data *target, int type); +typedef void (*HPMHOOK_pre_clif_bc_ready) (void); +typedef void (*HPMHOOK_post_clif_bc_ready) (void); +typedef void (*HPMHOOK_pre_clif_channel_msg) (struct channel_data **chan, struct map_session_data **sd, char **msg); +typedef void (*HPMHOOK_post_clif_channel_msg) (struct channel_data *chan, struct map_session_data *sd, char *msg); +typedef void (*HPMHOOK_pre_clif_channel_msg2) (struct channel_data **chan, char **msg); +typedef void (*HPMHOOK_post_clif_channel_msg2) (struct channel_data *chan, char *msg); +typedef int (*HPMHOOK_pre_clif_undisguise_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_clif_undisguise_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_clif_bank_deposit) (struct map_session_data **sd, enum e_BANKING_DEPOSIT_ACK *reason); +typedef void (*HPMHOOK_post_clif_bank_deposit) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK reason); +typedef void (*HPMHOOK_pre_clif_bank_withdraw) (struct map_session_data **sd, enum e_BANKING_WITHDRAW_ACK *reason); +typedef void (*HPMHOOK_post_clif_bank_withdraw) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK reason); +typedef void (*HPMHOOK_pre_clif_show_modifiers) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_show_modifiers) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_notify_bounditem) (struct map_session_data **sd, unsigned short *index); +typedef void (*HPMHOOK_post_clif_notify_bounditem) (struct map_session_data *sd, unsigned short index); +typedef int (*HPMHOOK_pre_clif_delay_damage) (int64 *tick, struct block_list **src, struct block_list **dst, int *sdelay, int *ddelay, int64 *in_damage, short *div, unsigned char *type); +typedef int (*HPMHOOK_post_clif_delay_damage) (int retVal___, int64 tick, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 in_damage, short div, unsigned char type); +typedef int (*HPMHOOK_pre_clif_delay_damage_sub) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_clif_delay_damage_sub) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_clif_npc_market_open) (struct map_session_data **sd, struct npc_data **nd); +typedef void (*HPMHOOK_post_clif_npc_market_open) (struct map_session_data *sd, struct npc_data *nd); +typedef void (*HPMHOOK_pre_clif_npc_market_purchase_ack) (struct map_session_data **sd, const struct itemlist **item_list, unsigned char *response); +typedef void (*HPMHOOK_post_clif_npc_market_purchase_ack) (struct map_session_data *sd, const struct itemlist *item_list, unsigned char response); +typedef bool (*HPMHOOK_pre_clif_parse_roulette_db) (void); +typedef bool (*HPMHOOK_post_clif_parse_roulette_db) (bool retVal___); +typedef void (*HPMHOOK_pre_clif_roulette_generate_ack) (struct map_session_data **sd, unsigned char *result, short *stage, short *prizeIdx, short *bonusItemID); +typedef void (*HPMHOOK_post_clif_roulette_generate_ack) (struct map_session_data *sd, unsigned char result, short stage, short prizeIdx, short bonusItemID); +typedef void (*HPMHOOK_pre_clif_openmergeitem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_openmergeitem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_cancelmergeitem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_cancelmergeitem) (int fd, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_clif_comparemergeitem) (const void **a, const void **b); +typedef int (*HPMHOOK_post_clif_comparemergeitem) (int retVal___, const void *a, const void *b); +typedef void (*HPMHOOK_pre_clif_ackmergeitems) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_ackmergeitems) (int fd, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_clif_isdisguised) (struct block_list **bl); +typedef bool (*HPMHOOK_post_clif_isdisguised) (bool retVal___, struct block_list *bl); +typedef unsigned char (*HPMHOOK_pre_clif_bl_type) (struct block_list **bl); +typedef unsigned char (*HPMHOOK_post_clif_bl_type) (unsigned char retVal___, struct block_list *bl); +typedef void (*HPMHOOK_pre_clif_pWantToConnection) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pWantToConnection) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pLoadEndAck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pLoadEndAck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTickSend) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTickSend) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHotkey) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHotkey) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pProgressbar) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pProgressbar) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pWalkToXY) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pWalkToXY) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pQuitGame) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pQuitGame) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGetCharNameRequest) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGetCharNameRequest) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGlobalMessage) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGlobalMessage) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMapMove) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMapMove) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChangeDir) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChangeDir) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pEmotion) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pEmotion) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHowManyConnections) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHowManyConnections) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pActionRequest) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pActionRequest) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pActionRequest_sub) (struct map_session_data **sd, int *action_type, int *target_id, int64 *tick); +typedef void (*HPMHOOK_post_clif_pActionRequest_sub) (struct map_session_data *sd, int action_type, int target_id, int64 tick); +typedef void (*HPMHOOK_pre_clif_pRestart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRestart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pWisMessage) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pWisMessage) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBroadcast) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBroadcast) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTakeItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTakeItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pDropItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pDropItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pEquipItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pEquipItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUnequipItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUnequipItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcClicked) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcClicked) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcBuySellSelected) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcBuySellSelected) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcBuyListSend) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcBuyListSend) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcSellListSend) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcSellListSend) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCreateChatRoom) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCreateChatRoom) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChatAddMember) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChatAddMember) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChatRoomStatusChange) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChatRoomStatusChange) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChangeChatOwner) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChangeChatOwner) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pKickFromChat) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pKickFromChat) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChatLeave) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChatLeave) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeRequest) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeRequest) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeAck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeAck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeAddItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeAddItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeOk) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeOk) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeCancel) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeCancel) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTradeCommit) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTradeCommit) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pStopAttack) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pStopAttack) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPutItemToCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPutItemToCart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGetItemFromCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGetItemFromCart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRemoveOption) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRemoveOption) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChangeCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChangeCart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pStatusUp) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pStatusUp) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSkillUp) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSkillUp) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseSkillToId) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseSkillToId) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseSkillToId_homun) (struct homun_data **hd, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); +typedef void (*HPMHOOK_post_clif_pUseSkillToId_homun) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id); +typedef void (*HPMHOOK_pre_clif_pUseSkillToId_mercenary) (struct mercenary_data **md, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); +typedef void (*HPMHOOK_post_clif_pUseSkillToId_mercenary) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id); +typedef void (*HPMHOOK_pre_clif_pUseSkillToPos) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseSkillToPos) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseSkillToPosSub) (int *fd, struct map_session_data **sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo); +typedef void (*HPMHOOK_post_clif_pUseSkillToPosSub) (int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo); +typedef void (*HPMHOOK_pre_clif_pUseSkillToPos_homun) (struct homun_data **hd, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); +typedef void (*HPMHOOK_post_clif_pUseSkillToPos_homun) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo); +typedef void (*HPMHOOK_pre_clif_pUseSkillToPos_mercenary) (struct mercenary_data **md, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); +typedef void (*HPMHOOK_post_clif_pUseSkillToPos_mercenary) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo); +typedef void (*HPMHOOK_pre_clif_pUseSkillToPosMoreInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseSkillToPosMoreInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseSkillMap) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseSkillMap) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRequestMemo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRequestMemo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pProduceMix) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pProduceMix) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCooking) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCooking) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRepairItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRepairItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pWeaponRefine) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pWeaponRefine) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcSelectMenu) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcSelectMenu) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcNextClicked) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcNextClicked) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcAmountInput) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcAmountInput) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcStringInput) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcStringInput) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNpcCloseClicked) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNpcCloseClicked) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pItemIdentify) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pItemIdentify) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSelectArrow) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSelectArrow) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAutoSpell) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAutoSpell) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pUseCard) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pUseCard) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pInsertCard) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pInsertCard) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSolveCharName) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSolveCharName) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pResetChar) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pResetChar) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pLocalBroadcast) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pLocalBroadcast) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMoveToKafra) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMoveToKafra) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMoveFromKafra) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMoveFromKafra) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMoveToKafraFromCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMoveToKafraFromCart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMoveFromKafraToCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMoveFromKafraToCart) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCloseKafra) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCloseKafra) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pStoragePassword) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pStoragePassword) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCreateParty) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCreateParty) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCreateParty2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCreateParty2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyInvite) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyInvite) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyInvite2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyInvite2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReplyPartyInvite) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReplyPartyInvite) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReplyPartyInvite2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReplyPartyInvite2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pLeaveParty) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pLeaveParty) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRemovePartyMember) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRemovePartyMember) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyChangeOption) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyChangeOption) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyMessage) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyMessage) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyChangeLeader) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyChangeLeader) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingRegisterReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingRegisterReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingSearchReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingSearchReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingDeleteReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingDeleteReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingUpdateReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingUpdateReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyRecruitRegisterReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyRecruitRegisterReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyRecruitSearchReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyRecruitSearchReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyRecruitDeleteReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyRecruitDeleteReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyRecruitUpdateReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyRecruitUpdateReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCloseVending) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCloseVending) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pVendingListReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pVendingListReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPurchaseReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPurchaseReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPurchaseReq2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPurchaseReq2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pOpenVending) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pOpenVending) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCreateGuild) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCreateGuild) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildCheckMaster) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildCheckMaster) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildRequestInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildRequestInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildChangePositionInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildChangePositionInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildChangeMemberPosition) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildChangeMemberPosition) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildRequestEmblem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildRequestEmblem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildChangeEmblem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildChangeEmblem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildChangeNotice) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildChangeNotice) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildInvite) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildInvite) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildReplyInvite) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildReplyInvite) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildLeave) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildLeave) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildExpulsion) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildExpulsion) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildMessage) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildMessage) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildRequestAlliance) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildRequestAlliance) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildReplyAlliance) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildReplyAlliance) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildDelAlliance) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildDelAlliance) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildOpposition) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildOpposition) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildBreak) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildBreak) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPetMenu) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPetMenu) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCatchPet) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCatchPet) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSelectEgg) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSelectEgg) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSendEmotion) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSendEmotion) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChangePetName) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChangePetName) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMKick) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMKick) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMKickAll) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMKickAll) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMShift) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMShift) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMRemove2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMRemove2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMRecall) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMRecall) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMRecall2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMRecall2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGM_Monster_Item) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGM_Monster_Item) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMHide) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMHide) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMReqNoChat) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMReqNoChat) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMRc) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMRc) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMReqAccountName) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMReqAccountName) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMChangeMapType) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMChangeMapType) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGMFullStrip) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGMFullStrip) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPMIgnore) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPMIgnore) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPMIgnoreAll) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPMIgnoreAll) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPMIgnoreList) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPMIgnoreList) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNoviceDoriDori) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNoviceDoriDori) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNoviceExplosionSpirits) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNoviceExplosionSpirits) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pFriendsListAdd) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pFriendsListAdd) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pFriendsListReply) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pFriendsListReply) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pFriendsListRemove) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pFriendsListRemove) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPVPInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPVPInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBlacksmith) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBlacksmith) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAlchemist) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAlchemist) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pTaekwon) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pTaekwon) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRankingPk) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRankingPk) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pFeelSaveOk) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pFeelSaveOk) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pChangeHomunculusName) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pChangeHomunculusName) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHomMoveToMaster) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHomMoveToMaster) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHomMoveTo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHomMoveTo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHomAttack) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHomAttack) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pHomMenu) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHomMenu) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAutoRevive) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAutoRevive) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCheck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCheck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_refreshinbox) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_refreshinbox) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_read) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_read) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_getattach) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_getattach) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_delete) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_delete) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_return) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_return) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_setattach) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_setattach) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_winopen) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_winopen) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMail_send) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMail_send) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_cancelreg) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_cancelreg) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_setitem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_setitem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_register) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_register) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_cancel) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_cancel) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_close) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_close) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_bid) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_bid) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_search) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_search) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAuction_buysell) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAuction_buysell) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pcashshop_buy) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pcashshop_buy) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAdopt_request) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAdopt_request) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pAdopt_reply) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pAdopt_reply) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pViewPlayerEquip) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pViewPlayerEquip) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pEquipTick) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pEquipTick) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pquestStateAck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pquestStateAck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pmercenary_action) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pmercenary_action) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBattleChat) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBattleChat) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pLessEffect) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pLessEffect) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pItemListWindowSelected) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pItemListWindowSelected) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReqOpenBuyingStore) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReqOpenBuyingStore) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReqCloseBuyingStore) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReqCloseBuyingStore) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReqClickBuyingStore) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReqClickBuyingStore) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pReqTradeBuyingStore) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pReqTradeBuyingStore) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSearchStoreInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSearchStoreInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSearchStoreInfoNextPage) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSearchStoreInfoNextPage) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCloseSearchStoreInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCloseSearchStoreInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSearchStoreInfoListItemClick) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSearchStoreInfoListItemClick) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pDebug) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pDebug) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSkillSelectMenu) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSkillSelectMenu) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pMoveItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pMoveItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pDull) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pDull) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBGQueueRegister) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBGQueueRegister) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBGQueueCheckState) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBGQueueCheckState) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBGQueueRevokeReq) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBGQueueRevokeReq) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBGQueueBattleBeginAck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBGQueueBattleBeginAck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCashShopOpen) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCashShopOpen) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCashShopClose) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCashShopClose) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCashShopReqTab) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCashShopReqTab) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCashShopSchedule) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCashShopSchedule) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pCashShopBuy) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pCashShopBuy) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyTick) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyTick) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pGuildInvite2) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pGuildInvite2) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingAddFilter) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingAddFilter) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingSubFilter) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingSubFilter) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingReqVolunteer) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingReqVolunteer) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingRefuseVolunteer) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingRefuseVolunteer) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pPartyBookingCancelVolunteer) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pPartyBookingCancelVolunteer) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBankDeposit) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBankDeposit) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBankWithdraw) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBankWithdraw) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBankCheck) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBankCheck) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBankOpen) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBankOpen) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pBankClose) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pBankClose) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRouletteOpen) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRouletteOpen) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRouletteInfo) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRouletteInfo) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRouletteClose) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRouletteClose) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRouletteGenerate) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRouletteGenerate) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pRouletteRecvItem) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pRouletteRecvItem) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNPCShopClosed) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNPCShopClosed) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNPCMarketClosed) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNPCMarketClosed) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pNPCMarketPurchase) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pNPCMarketPurchase) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_add_random_options) (unsigned char **buf, struct item **item); +typedef void (*HPMHOOK_post_clif_add_random_options) (unsigned char *buf, struct item *item); +typedef void (*HPMHOOK_pre_clif_pHotkeyRowShift) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pHotkeyRowShift) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_dressroom_open) (struct map_session_data **sd, int *view); +typedef void (*HPMHOOK_post_clif_dressroom_open) (struct map_session_data *sd, int view); +typedef void (*HPMHOOK_pre_clif_pOneClick_ItemIdentify) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pOneClick_ItemIdentify) (int fd, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_selectcart) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_selectcart) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_clif_pSelectCart) (int *fd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_clif_pSelectCart) (int fd, struct map_session_data *sd); +typedef const char* (*HPMHOOK_pre_clif_get_bl_name) (const struct block_list **bl); +typedef const char* (*HPMHOOK_post_clif_get_bl_name) (const char* retVal___, const struct block_list *bl); +#endif // MAP_CLIF_H +#ifdef COMMON_CORE_H /* cmdline */ +typedef void (*HPMHOOK_pre_cmdline_init) (void); +typedef void (*HPMHOOK_post_cmdline_init) (void); +typedef void (*HPMHOOK_pre_cmdline_final) (void); +typedef void (*HPMHOOK_post_cmdline_final) (void); +typedef bool (*HPMHOOK_pre_cmdline_arg_add) (unsigned int *pluginID, const char **name, char *shortname, CmdlineExecFunc *func, const char **help, unsigned int *options); +typedef bool (*HPMHOOK_post_cmdline_arg_add) (bool retVal___, unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options); +typedef int (*HPMHOOK_pre_cmdline_exec) (int *argc, char ***argv, unsigned int *options); +typedef int (*HPMHOOK_post_cmdline_exec) (int retVal___, int argc, char **argv, unsigned int options); +typedef bool (*HPMHOOK_pre_cmdline_arg_next_value) (const char **name, int *current_arg, int *argc); +typedef bool (*HPMHOOK_post_cmdline_arg_next_value) (bool retVal___, const char *name, int current_arg, int argc); +typedef const char* (*HPMHOOK_pre_cmdline_arg_source) (struct CmdlineArgData **arg); +typedef const char* (*HPMHOOK_post_cmdline_arg_source) (const char* retVal___, struct CmdlineArgData *arg); +#endif // COMMON_CORE_H +#ifdef COMMON_CONSOLE_H /* console */ +typedef void (*HPMHOOK_pre_console_init) (void); +typedef void (*HPMHOOK_post_console_init) (void); +typedef void (*HPMHOOK_pre_console_final) (void); +typedef void (*HPMHOOK_post_console_final) (void); +typedef void (*HPMHOOK_pre_console_display_title) (void); +typedef void (*HPMHOOK_post_console_display_title) (void); +typedef void (*HPMHOOK_pre_console_display_gplnotice) (void); +typedef void (*HPMHOOK_post_console_display_gplnotice) (void); +#endif // COMMON_CONSOLE_H +#ifdef COMMON_CORE_H /* core */ +typedef void (*HPMHOOK_pre_core_shutdown_callback) (void); +typedef void (*HPMHOOK_post_core_shutdown_callback) (void); +#endif // COMMON_CORE_H +#ifdef COMMON_DB_H /* DB */ +typedef enum DBOptions (*HPMHOOK_pre_DB_fix_options) (enum DBType *type, enum DBOptions *options); +typedef enum DBOptions (*HPMHOOK_post_DB_fix_options) (enum DBOptions retVal___, enum DBType type, enum DBOptions options); +typedef DBComparator (*HPMHOOK_pre_DB_default_cmp) (enum DBType *type); +typedef DBComparator (*HPMHOOK_post_DB_default_cmp) (DBComparator retVal___, enum DBType type); +typedef DBHasher (*HPMHOOK_pre_DB_default_hash) (enum DBType *type); +typedef DBHasher (*HPMHOOK_post_DB_default_hash) (DBHasher retVal___, enum DBType type); +typedef DBReleaser (*HPMHOOK_pre_DB_default_release) (enum DBType *type, enum DBOptions *options); +typedef DBReleaser (*HPMHOOK_post_DB_default_release) (DBReleaser retVal___, enum DBType type, enum DBOptions options); +typedef DBReleaser (*HPMHOOK_pre_DB_custom_release) (enum DBReleaseOption *which); +typedef DBReleaser (*HPMHOOK_post_DB_custom_release) (DBReleaser retVal___, enum DBReleaseOption which); +typedef struct DBMap* (*HPMHOOK_pre_DB_alloc) (const char **file, const char **func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); +typedef struct DBMap* (*HPMHOOK_post_DB_alloc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen); +typedef union DBKey (*HPMHOOK_pre_DB_i2key) (int *key); +typedef union DBKey (*HPMHOOK_post_DB_i2key) (union DBKey retVal___, int key); +typedef union DBKey (*HPMHOOK_pre_DB_ui2key) (unsigned int *key); +typedef union DBKey (*HPMHOOK_post_DB_ui2key) (union DBKey retVal___, unsigned int key); +typedef union DBKey (*HPMHOOK_pre_DB_str2key) (const char **key); +typedef union DBKey (*HPMHOOK_post_DB_str2key) (union DBKey retVal___, const char *key); +typedef union DBKey (*HPMHOOK_pre_DB_i642key) (int64 *key); +typedef union DBKey (*HPMHOOK_post_DB_i642key) (union DBKey retVal___, int64 key); +typedef union DBKey (*HPMHOOK_pre_DB_ui642key) (uint64 *key); +typedef union DBKey (*HPMHOOK_post_DB_ui642key) (union DBKey retVal___, uint64 key); +typedef struct DBData (*HPMHOOK_pre_DB_i2data) (int *data); +typedef struct DBData (*HPMHOOK_post_DB_i2data) (struct DBData retVal___, int data); +typedef struct DBData (*HPMHOOK_pre_DB_ui2data) (unsigned int *data); +typedef struct DBData (*HPMHOOK_post_DB_ui2data) (struct DBData retVal___, unsigned int data); +typedef struct DBData (*HPMHOOK_pre_DB_ptr2data) (void **data); +typedef struct DBData (*HPMHOOK_post_DB_ptr2data) (struct DBData retVal___, void *data); +typedef int (*HPMHOOK_pre_DB_data2i) (struct DBData **data); +typedef int (*HPMHOOK_post_DB_data2i) (int retVal___, struct DBData *data); +typedef unsigned int (*HPMHOOK_pre_DB_data2ui) (struct DBData **data); +typedef unsigned int (*HPMHOOK_post_DB_data2ui) (unsigned int retVal___, struct DBData *data); +typedef void* (*HPMHOOK_pre_DB_data2ptr) (struct DBData **data); +typedef void* (*HPMHOOK_post_DB_data2ptr) (void* retVal___, struct DBData *data); +typedef void (*HPMHOOK_pre_DB_init) (void); +typedef void (*HPMHOOK_post_DB_init) (void); +typedef void (*HPMHOOK_pre_DB_final) (void); +typedef void (*HPMHOOK_post_DB_final) (void); +#endif // COMMON_DB_H +#ifdef MAP_DUEL_H /* duel */ +typedef int (*HPMHOOK_pre_duel_create) (struct map_session_data **sd, const unsigned int *maxpl); +typedef int (*HPMHOOK_post_duel_create) (int retVal___, struct map_session_data *sd, const unsigned int maxpl); +typedef void (*HPMHOOK_pre_duel_invite) (const unsigned int *did, struct map_session_data **sd, struct map_session_data **target_sd); +typedef void (*HPMHOOK_post_duel_invite) (const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd); +typedef void (*HPMHOOK_pre_duel_accept) (const unsigned int *did, struct map_session_data **sd); +typedef void (*HPMHOOK_post_duel_accept) (const unsigned int did, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_duel_reject) (const unsigned int *did, struct map_session_data **sd); +typedef void (*HPMHOOK_post_duel_reject) (const unsigned int did, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_duel_leave) (const unsigned int *did, struct map_session_data **sd); +typedef void (*HPMHOOK_post_duel_leave) (const unsigned int did, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_duel_showinfo) (const unsigned int *did, struct map_session_data **sd); +typedef void (*HPMHOOK_post_duel_showinfo) (const unsigned int did, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_duel_checktime) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_duel_checktime) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_duel_init) (bool *minimal); +typedef void (*HPMHOOK_post_duel_init) (bool minimal); +typedef void (*HPMHOOK_pre_duel_final) (void); +typedef void (*HPMHOOK_post_duel_final) (void); +#endif // MAP_DUEL_H +#ifdef MAP_ELEMENTAL_H /* elemental */ +typedef int (*HPMHOOK_pre_elemental_init) (bool *minimal); +typedef int (*HPMHOOK_post_elemental_init) (int retVal___, bool minimal); +typedef void (*HPMHOOK_pre_elemental_final) (void); +typedef void (*HPMHOOK_post_elemental_final) (void); +typedef bool (*HPMHOOK_pre_elemental_class) (int *class_); +typedef bool (*HPMHOOK_post_elemental_class) (bool retVal___, int class_); +typedef struct view_data* (*HPMHOOK_pre_elemental_get_viewdata) (int *class_); +typedef struct view_data* (*HPMHOOK_post_elemental_get_viewdata) (struct view_data* retVal___, int class_); +typedef int (*HPMHOOK_pre_elemental_create) (struct map_session_data **sd, int *class_, unsigned int *lifetime); +typedef int (*HPMHOOK_post_elemental_create) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime); +typedef int (*HPMHOOK_pre_elemental_data_received) (const struct s_elemental **ele, bool *flag); +typedef int (*HPMHOOK_post_elemental_data_received) (int retVal___, const struct s_elemental *ele, bool flag); +typedef int (*HPMHOOK_pre_elemental_save) (struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_save) (int retVal___, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_change_mode_ack) (struct elemental_data **ed, int *mode); +typedef int (*HPMHOOK_post_elemental_change_mode_ack) (int retVal___, struct elemental_data *ed, int mode); +typedef int (*HPMHOOK_pre_elemental_change_mode) (struct elemental_data **ed, uint32 *mode); +typedef int (*HPMHOOK_post_elemental_change_mode) (int retVal___, struct elemental_data *ed, uint32 mode); +typedef void (*HPMHOOK_pre_elemental_heal) (struct elemental_data **ed, int *hp, int *sp); +typedef void (*HPMHOOK_post_elemental_heal) (struct elemental_data *ed, int hp, int sp); +typedef int (*HPMHOOK_pre_elemental_dead) (struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_dead) (int retVal___, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_delete) (struct elemental_data **ed, int *reply); +typedef int (*HPMHOOK_post_elemental_delete) (int retVal___, struct elemental_data *ed, int reply); +typedef void (*HPMHOOK_pre_elemental_summon_stop) (struct elemental_data **ed); +typedef void (*HPMHOOK_post_elemental_summon_stop) (struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_get_lifetime) (struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_get_lifetime) (int retVal___, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_unlocktarget) (struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_unlocktarget) (int retVal___, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_skillnotok) (uint16 *skill_id, struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_skillnotok) (int retVal___, uint16 skill_id, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_set_target) (struct map_session_data **sd, struct block_list **bl); +typedef int (*HPMHOOK_post_elemental_set_target) (int retVal___, struct map_session_data *sd, struct block_list *bl); +typedef int (*HPMHOOK_pre_elemental_clean_single_effect) (struct elemental_data **ed, uint16 *skill_id); +typedef int (*HPMHOOK_post_elemental_clean_single_effect) (int retVal___, struct elemental_data *ed, uint16 skill_id); +typedef int (*HPMHOOK_pre_elemental_clean_effect) (struct elemental_data **ed); +typedef int (*HPMHOOK_post_elemental_clean_effect) (int retVal___, struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_action) (struct elemental_data **ed, struct block_list **bl, int64 *tick); +typedef int (*HPMHOOK_post_elemental_action) (int retVal___, struct elemental_data *ed, struct block_list *bl, int64 tick); +typedef struct skill_condition (*HPMHOOK_pre_elemental_skill_get_requirements) (uint16 *skill_id, uint16 *skill_lv); +typedef struct skill_condition (*HPMHOOK_post_elemental_skill_get_requirements) (struct skill_condition retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_elemental_read_skilldb) (void); +typedef int (*HPMHOOK_post_elemental_read_skilldb) (int retVal___); +typedef void (*HPMHOOK_pre_elemental_reload_db) (void); +typedef void (*HPMHOOK_post_elemental_reload_db) (void); +typedef void (*HPMHOOK_pre_elemental_reload_skilldb) (void); +typedef void (*HPMHOOK_post_elemental_reload_skilldb) (void); +typedef int (*HPMHOOK_pre_elemental_search_index) (int *class_); +typedef int (*HPMHOOK_post_elemental_search_index) (int retVal___, int class_); +typedef void (*HPMHOOK_pre_elemental_summon_init) (struct elemental_data **ed); +typedef void (*HPMHOOK_post_elemental_summon_init) (struct elemental_data *ed); +typedef int (*HPMHOOK_pre_elemental_summon_end_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_elemental_summon_end_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_elemental_ai_sub_timer_activesearch) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_elemental_ai_sub_timer_activesearch) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_elemental_ai_sub_timer) (struct elemental_data **ed, struct map_session_data **sd, int64 *tick); +typedef int (*HPMHOOK_post_elemental_ai_sub_timer) (int retVal___, struct elemental_data *ed, struct map_session_data *sd, int64 tick); +typedef int (*HPMHOOK_pre_elemental_ai_sub_foreachclient) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_elemental_ai_sub_foreachclient) (int retVal___, struct map_session_data *sd, va_list ap); +typedef int (*HPMHOOK_pre_elemental_ai_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_elemental_ai_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_elemental_read_db) (void); +typedef int (*HPMHOOK_post_elemental_read_db) (int retVal___); +#endif // MAP_ELEMENTAL_H +#ifdef CHAR_GEOIP_H /* geoip */ +typedef const char* (*HPMHOOK_pre_geoip_getcountry) (uint32 *ipnum); +typedef const char* (*HPMHOOK_post_geoip_getcountry) (const char* retVal___, uint32 ipnum); +typedef void (*HPMHOOK_pre_geoip_final) (bool *shutdown); +typedef void (*HPMHOOK_post_geoip_final) (bool shutdown); +typedef void (*HPMHOOK_pre_geoip_init) (void); +typedef void (*HPMHOOK_post_geoip_init) (void); +#endif // CHAR_GEOIP_H +#ifdef MAP_GUILD_H /* guild */ +typedef void (*HPMHOOK_pre_guild_init) (bool *minimal); +typedef void (*HPMHOOK_post_guild_init) (bool minimal); +typedef void (*HPMHOOK_pre_guild_final) (void); +typedef void (*HPMHOOK_post_guild_final) (void); +typedef int (*HPMHOOK_pre_guild_skill_get_max) (int *id); +typedef int (*HPMHOOK_post_guild_skill_get_max) (int retVal___, int id); +typedef int (*HPMHOOK_pre_guild_checkskill) (struct guild **g, int *id); +typedef int (*HPMHOOK_post_guild_checkskill) (int retVal___, struct guild *g, int id); +typedef int (*HPMHOOK_pre_guild_check_skill_require) (struct guild **g, int *id); +typedef int (*HPMHOOK_post_guild_check_skill_require) (int retVal___, struct guild *g, int id); +typedef int (*HPMHOOK_pre_guild_checkcastles) (struct guild **g); +typedef int (*HPMHOOK_post_guild_checkcastles) (int retVal___, struct guild *g); +typedef bool (*HPMHOOK_pre_guild_isallied) (int *guild_id, int *guild_id2); +typedef bool (*HPMHOOK_post_guild_isallied) (bool retVal___, int guild_id, int guild_id2); +typedef struct guild* (*HPMHOOK_pre_guild_search) (int *guild_id); +typedef struct guild* (*HPMHOOK_post_guild_search) (struct guild* retVal___, int guild_id); +typedef struct guild* (*HPMHOOK_pre_guild_searchname) (char **str); +typedef struct guild* (*HPMHOOK_post_guild_searchname) (struct guild* retVal___, char *str); +typedef struct guild_castle* (*HPMHOOK_pre_guild_castle_search) (int *gcid); +typedef struct guild_castle* (*HPMHOOK_post_guild_castle_search) (struct guild_castle* retVal___, int gcid); +typedef struct guild_castle* (*HPMHOOK_pre_guild_mapname2gc) (const char **mapname); +typedef struct guild_castle* (*HPMHOOK_post_guild_mapname2gc) (struct guild_castle* retVal___, const char *mapname); +typedef struct guild_castle* (*HPMHOOK_pre_guild_mapindex2gc) (short *map_index); +typedef struct guild_castle* (*HPMHOOK_post_guild_mapindex2gc) (struct guild_castle* retVal___, short map_index); +typedef struct map_session_data* (*HPMHOOK_pre_guild_getavailablesd) (struct guild **g); +typedef struct map_session_data* (*HPMHOOK_post_guild_getavailablesd) (struct map_session_data* retVal___, struct guild *g); +typedef int (*HPMHOOK_pre_guild_getindex) (const struct guild **g, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_guild_getindex) (int retVal___, const struct guild *g, int account_id, int char_id); +typedef int (*HPMHOOK_pre_guild_getposition) (struct guild **g, struct map_session_data **sd); +typedef int (*HPMHOOK_post_guild_getposition) (int retVal___, struct guild *g, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_guild_payexp) (struct map_session_data **sd, unsigned int *exp); +typedef unsigned int (*HPMHOOK_post_guild_payexp) (unsigned int retVal___, struct map_session_data *sd, unsigned int exp); +typedef int (*HPMHOOK_pre_guild_getexp) (struct map_session_data **sd, int *exp); +typedef int (*HPMHOOK_post_guild_getexp) (int retVal___, struct map_session_data *sd, int exp); +typedef int (*HPMHOOK_pre_guild_create) (struct map_session_data **sd, const char **name); +typedef int (*HPMHOOK_post_guild_create) (int retVal___, struct map_session_data *sd, const char *name); +typedef int (*HPMHOOK_pre_guild_created) (int *account_id, int *guild_id); +typedef int (*HPMHOOK_post_guild_created) (int retVal___, int account_id, int guild_id); +typedef int (*HPMHOOK_pre_guild_request_info) (int *guild_id); +typedef int (*HPMHOOK_post_guild_request_info) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_guild_recv_noinfo) (int *guild_id); +typedef int (*HPMHOOK_post_guild_recv_noinfo) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_guild_recv_info) (const struct guild **sg); +typedef int (*HPMHOOK_post_guild_recv_info) (int retVal___, const struct guild *sg); +typedef int (*HPMHOOK_pre_guild_npc_request_info) (int *guild_id, const char **ev); +typedef int (*HPMHOOK_post_guild_npc_request_info) (int retVal___, int guild_id, const char *ev); +typedef int (*HPMHOOK_pre_guild_invite) (struct map_session_data **sd, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_guild_invite) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd); +typedef int (*HPMHOOK_pre_guild_reply_invite) (struct map_session_data **sd, int *guild_id, int *flag); +typedef int (*HPMHOOK_post_guild_reply_invite) (int retVal___, struct map_session_data *sd, int guild_id, int flag); +typedef void (*HPMHOOK_pre_guild_member_joined) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_guild_member_joined) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_guild_member_added) (int *guild_id, int *account_id, int *char_id, int *flag); +typedef int (*HPMHOOK_post_guild_member_added) (int retVal___, int guild_id, int account_id, int char_id, int flag); +typedef int (*HPMHOOK_pre_guild_leave) (struct map_session_data **sd, int *guild_id, int *account_id, int *char_id, const char **mes); +typedef int (*HPMHOOK_post_guild_leave) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes); +typedef int (*HPMHOOK_pre_guild_member_withdraw) (int *guild_id, int *account_id, int *char_id, int *flag, const char **name, const char **mes); +typedef int (*HPMHOOK_post_guild_member_withdraw) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes); +typedef int (*HPMHOOK_pre_guild_expulsion) (struct map_session_data **sd, int *guild_id, int *account_id, int *char_id, const char **mes); +typedef int (*HPMHOOK_post_guild_expulsion) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes); +typedef int (*HPMHOOK_pre_guild_skillup) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_guild_skillup) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef void (*HPMHOOK_pre_guild_block_skill) (struct map_session_data **sd, int *time); +typedef void (*HPMHOOK_post_guild_block_skill) (struct map_session_data *sd, int time); +typedef int (*HPMHOOK_pre_guild_reqalliance) (struct map_session_data **sd, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_guild_reqalliance) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd); +typedef int (*HPMHOOK_pre_guild_reply_reqalliance) (struct map_session_data **sd, int *account_id, int *flag); +typedef int (*HPMHOOK_post_guild_reply_reqalliance) (int retVal___, struct map_session_data *sd, int account_id, int flag); +typedef int (*HPMHOOK_pre_guild_allianceack) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char **name1, const char **name2); +typedef int (*HPMHOOK_post_guild_allianceack) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2); +typedef int (*HPMHOOK_pre_guild_delalliance) (struct map_session_data **sd, int *guild_id, int *flag); +typedef int (*HPMHOOK_post_guild_delalliance) (int retVal___, struct map_session_data *sd, int guild_id, int flag); +typedef int (*HPMHOOK_pre_guild_opposition) (struct map_session_data **sd, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_guild_opposition) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd); +typedef int (*HPMHOOK_pre_guild_check_alliance) (int *guild_id1, int *guild_id2, int *flag); +typedef int (*HPMHOOK_post_guild_check_alliance) (int retVal___, int guild_id1, int guild_id2, int flag); +typedef int (*HPMHOOK_pre_guild_send_memberinfoshort) (struct map_session_data **sd, int *online); +typedef int (*HPMHOOK_post_guild_send_memberinfoshort) (int retVal___, struct map_session_data *sd, int online); +typedef int (*HPMHOOK_pre_guild_recv_memberinfoshort) (int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); +typedef int (*HPMHOOK_post_guild_recv_memberinfoshort) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_); +typedef int (*HPMHOOK_pre_guild_change_memberposition) (int *guild_id, int *account_id, int *char_id, short *idx); +typedef int (*HPMHOOK_post_guild_change_memberposition) (int retVal___, int guild_id, int account_id, int char_id, short idx); +typedef int (*HPMHOOK_pre_guild_memberposition_changed) (struct guild **g, int *idx, int *pos); +typedef int (*HPMHOOK_post_guild_memberposition_changed) (int retVal___, struct guild *g, int idx, int pos); +typedef int (*HPMHOOK_pre_guild_change_position) (int *guild_id, int *idx, int *mode, int *exp_mode, const char **name); +typedef int (*HPMHOOK_post_guild_change_position) (int retVal___, int guild_id, int idx, int mode, int exp_mode, const char *name); +typedef int (*HPMHOOK_pre_guild_position_changed) (int *guild_id, int *idx, const struct guild_position **p); +typedef int (*HPMHOOK_post_guild_position_changed) (int retVal___, int guild_id, int idx, const struct guild_position *p); +typedef int (*HPMHOOK_pre_guild_change_notice) (struct map_session_data **sd, int *guild_id, const char **mes1, const char **mes2); +typedef int (*HPMHOOK_post_guild_change_notice) (int retVal___, struct map_session_data *sd, int guild_id, const char *mes1, const char *mes2); +typedef int (*HPMHOOK_pre_guild_notice_changed) (int *guild_id, const char **mes1, const char **mes2); +typedef int (*HPMHOOK_post_guild_notice_changed) (int retVal___, int guild_id, const char *mes1, const char *mes2); +typedef int (*HPMHOOK_pre_guild_change_emblem) (struct map_session_data **sd, int *len, const char **data); +typedef int (*HPMHOOK_post_guild_change_emblem) (int retVal___, struct map_session_data *sd, int len, const char *data); +typedef int (*HPMHOOK_pre_guild_emblem_changed) (int *len, int *guild_id, int *emblem_id, const char **data); +typedef int (*HPMHOOK_post_guild_emblem_changed) (int retVal___, int len, int guild_id, int emblem_id, const char *data); +typedef int (*HPMHOOK_pre_guild_send_message) (struct map_session_data **sd, const char **mes); +typedef int (*HPMHOOK_post_guild_send_message) (int retVal___, struct map_session_data *sd, const char *mes); +typedef int (*HPMHOOK_pre_guild_recv_message) (int *guild_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_guild_recv_message) (int retVal___, int guild_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_guild_send_dot_remove) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_guild_send_dot_remove) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_guild_skillupack) (int *guild_id, uint16 *skill_id, int *account_id); +typedef int (*HPMHOOK_post_guild_skillupack) (int retVal___, int guild_id, uint16 skill_id, int account_id); +typedef int (*HPMHOOK_pre_guild_dobreak) (struct map_session_data **sd, const char **name); +typedef int (*HPMHOOK_post_guild_dobreak) (int retVal___, struct map_session_data *sd, const char *name); +typedef int (*HPMHOOK_pre_guild_broken) (int *guild_id, int *flag); +typedef int (*HPMHOOK_post_guild_broken) (int retVal___, int guild_id, int flag); +typedef int (*HPMHOOK_pre_guild_gm_change) (int *guild_id, struct map_session_data **sd); +typedef int (*HPMHOOK_post_guild_gm_change) (int retVal___, int guild_id, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_guild_gm_changed) (int *guild_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_guild_gm_changed) (int retVal___, int guild_id, int account_id, int char_id); +typedef void (*HPMHOOK_pre_guild_castle_map_init) (void); +typedef void (*HPMHOOK_post_guild_castle_map_init) (void); +typedef int (*HPMHOOK_pre_guild_castledatasave) (int *castle_id, int *index, int *value); +typedef int (*HPMHOOK_post_guild_castledatasave) (int retVal___, int castle_id, int index, int value); +typedef int (*HPMHOOK_pre_guild_castledataloadack) (int *len, const struct guild_castle **gc); +typedef int (*HPMHOOK_post_guild_castledataloadack) (int retVal___, int len, const struct guild_castle *gc); +typedef void (*HPMHOOK_pre_guild_castle_reconnect) (int *castle_id, int *index, int *value); +typedef void (*HPMHOOK_post_guild_castle_reconnect) (int castle_id, int index, int value); +typedef void (*HPMHOOK_pre_guild_agit_start) (void); +typedef void (*HPMHOOK_post_guild_agit_start) (void); +typedef void (*HPMHOOK_pre_guild_agit_end) (void); +typedef void (*HPMHOOK_post_guild_agit_end) (void); +typedef void (*HPMHOOK_pre_guild_agit2_start) (void); +typedef void (*HPMHOOK_post_guild_agit2_start) (void); +typedef void (*HPMHOOK_pre_guild_agit2_end) (void); +typedef void (*HPMHOOK_post_guild_agit2_end) (void); +typedef void (*HPMHOOK_pre_guild_flag_add) (struct npc_data **nd); +typedef void (*HPMHOOK_post_guild_flag_add) (struct npc_data *nd); +typedef void (*HPMHOOK_pre_guild_flag_remove) (struct npc_data **nd); +typedef void (*HPMHOOK_post_guild_flag_remove) (struct npc_data *nd); +typedef void (*HPMHOOK_pre_guild_flags_clear) (void); +typedef void (*HPMHOOK_post_guild_flags_clear) (void); +typedef void (*HPMHOOK_pre_guild_aura_refresh) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef void (*HPMHOOK_post_guild_aura_refresh) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef void (*HPMHOOK_pre_guild_retrieveitembound) (int *char_id, int *aid, int *guild_id); +typedef void (*HPMHOOK_post_guild_retrieveitembound) (int char_id, int aid, int guild_id); +typedef int (*HPMHOOK_pre_guild_payexp_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_guild_payexp_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef struct map_session_data* (*HPMHOOK_pre_guild_sd_check) (int *guild_id, int *account_id, int *char_id); +typedef struct map_session_data* (*HPMHOOK_post_guild_sd_check) (struct map_session_data* retVal___, int guild_id, int account_id, int char_id); +typedef bool (*HPMHOOK_pre_guild_read_guildskill_tree_db) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_guild_read_guildskill_tree_db) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_guild_read_castledb) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_guild_read_castledb) (bool retVal___, char *str[], int columns, int current); +typedef int (*HPMHOOK_pre_guild_payexp_timer_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_payexp_timer_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_send_xy_timer_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_send_xy_timer_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_send_xy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_guild_send_xy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef struct DBData (*HPMHOOK_pre_guild_create_expcache) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_guild_create_expcache) (struct DBData retVal___, union DBKey key, va_list args); +typedef int (*HPMHOOK_pre_guild_eventlist_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_eventlist_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_expcache_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_expcache_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_castle_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_castle_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_broken_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_broken_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_guild_castle_broken_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_guild_castle_broken_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_guild_makemember) (struct guild_member **m, struct map_session_data **sd); +typedef void (*HPMHOOK_post_guild_makemember) (struct guild_member *m, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_guild_check_member) (const struct guild **g); +typedef int (*HPMHOOK_post_guild_check_member) (int retVal___, const struct guild *g); +typedef int (*HPMHOOK_pre_guild_get_alliance_count) (struct guild **g, int *flag); +typedef int (*HPMHOOK_post_guild_get_alliance_count) (int retVal___, struct guild *g, int flag); +typedef void (*HPMHOOK_pre_guild_castle_reconnect_sub) (void **key, void **data, va_list ap); +typedef void (*HPMHOOK_post_guild_castle_reconnect_sub) (void *key, void *data, va_list ap); +#endif // MAP_GUILD_H +#ifdef MAP_STORAGE_H /* gstorage */ +typedef struct guild_storage* (*HPMHOOK_pre_gstorage_ensure) (int *guild_id); +typedef struct guild_storage* (*HPMHOOK_post_gstorage_ensure) (struct guild_storage* retVal___, int guild_id); +typedef void (*HPMHOOK_pre_gstorage_init) (bool *minimal); +typedef void (*HPMHOOK_post_gstorage_init) (bool minimal); +typedef void (*HPMHOOK_pre_gstorage_final) (void); +typedef void (*HPMHOOK_post_gstorage_final) (void); +typedef int (*HPMHOOK_pre_gstorage_delete) (int *guild_id); +typedef int (*HPMHOOK_post_gstorage_delete) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_gstorage_open) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_gstorage_open) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_gstorage_additem) (struct map_session_data **sd, struct guild_storage **stor, struct item **item_data, int *amount); +typedef int (*HPMHOOK_post_gstorage_additem) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount); +typedef int (*HPMHOOK_pre_gstorage_delitem) (struct map_session_data **sd, struct guild_storage **stor, int *n, int *amount); +typedef int (*HPMHOOK_post_gstorage_delitem) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, int n, int amount); +typedef int (*HPMHOOK_pre_gstorage_add) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_gstorage_add) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_gstorage_get) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_gstorage_get) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_gstorage_addfromcart) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_gstorage_addfromcart) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_gstorage_gettocart) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_gstorage_gettocart) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_gstorage_close) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_gstorage_close) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_gstorage_pc_quit) (struct map_session_data **sd, int *flag); +typedef int (*HPMHOOK_post_gstorage_pc_quit) (int retVal___, struct map_session_data *sd, int flag); +typedef int (*HPMHOOK_pre_gstorage_save) (int *account_id, int *guild_id, int *flag); +typedef int (*HPMHOOK_post_gstorage_save) (int retVal___, int account_id, int guild_id, int flag); +typedef int (*HPMHOOK_pre_gstorage_saved) (int *guild_id); +typedef int (*HPMHOOK_post_gstorage_saved) (int retVal___, int guild_id); +typedef struct DBData (*HPMHOOK_pre_gstorage_create) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_gstorage_create) (struct DBData retVal___, union DBKey key, va_list args); +#endif // MAP_STORAGE_H +#ifdef MAP_HOMUNCULUS_H /* homun */ +typedef void (*HPMHOOK_pre_homun_init) (bool *minimal); +typedef void (*HPMHOOK_post_homun_init) (bool minimal); +typedef void (*HPMHOOK_pre_homun_final) (void); +typedef void (*HPMHOOK_post_homun_final) (void); +typedef void (*HPMHOOK_pre_homun_reload) (void); +typedef void (*HPMHOOK_post_homun_reload) (void); +typedef void (*HPMHOOK_pre_homun_reload_skill) (void); +typedef void (*HPMHOOK_post_homun_reload_skill) (void); +typedef struct view_data* (*HPMHOOK_pre_homun_get_viewdata) (int *class_); +typedef struct view_data* (*HPMHOOK_post_homun_get_viewdata) (struct view_data* retVal___, int class_); +typedef enum homun_type (*HPMHOOK_pre_homun_class2type) (int *class_); +typedef enum homun_type (*HPMHOOK_post_homun_class2type) (enum homun_type retVal___, int class_); +typedef void (*HPMHOOK_pre_homun_damaged) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_damaged) (struct homun_data *hd); +typedef int (*HPMHOOK_pre_homun_dead) (struct homun_data **hd); +typedef int (*HPMHOOK_post_homun_dead) (int retVal___, struct homun_data *hd); +typedef int (*HPMHOOK_pre_homun_vaporize) (struct map_session_data **sd, enum homun_state *flag); +typedef int (*HPMHOOK_post_homun_vaporize) (int retVal___, struct map_session_data *sd, enum homun_state flag); +typedef int (*HPMHOOK_pre_homun_delete) (struct homun_data **hd, int *emote); +typedef int (*HPMHOOK_post_homun_delete) (int retVal___, struct homun_data *hd, int emote); +typedef int (*HPMHOOK_pre_homun_checkskill) (struct homun_data **hd, uint16 *skill_id); +typedef int (*HPMHOOK_post_homun_checkskill) (int retVal___, struct homun_data *hd, uint16 skill_id); +typedef int (*HPMHOOK_pre_homun_calc_skilltree) (struct homun_data **hd, int *flag_evolve); +typedef int (*HPMHOOK_post_homun_calc_skilltree) (int retVal___, struct homun_data *hd, int flag_evolve); +typedef int (*HPMHOOK_pre_homun_skill_tree_get_max) (int *id, int *b_class); +typedef int (*HPMHOOK_post_homun_skill_tree_get_max) (int retVal___, int id, int b_class); +typedef void (*HPMHOOK_pre_homun_skillup) (struct homun_data **hd, uint16 *skill_id); +typedef void (*HPMHOOK_post_homun_skillup) (struct homun_data *hd, uint16 skill_id); +typedef bool (*HPMHOOK_pre_homun_levelup) (struct homun_data **hd); +typedef bool (*HPMHOOK_post_homun_levelup) (bool retVal___, struct homun_data *hd); +typedef int (*HPMHOOK_pre_homun_change_class) (struct homun_data **hd, short *class_); +typedef int (*HPMHOOK_post_homun_change_class) (int retVal___, struct homun_data *hd, short class_); +typedef bool (*HPMHOOK_pre_homun_evolve) (struct homun_data **hd); +typedef bool (*HPMHOOK_post_homun_evolve) (bool retVal___, struct homun_data *hd); +typedef bool (*HPMHOOK_pre_homun_mutate) (struct homun_data **hd, int *homun_id); +typedef bool (*HPMHOOK_post_homun_mutate) (bool retVal___, struct homun_data *hd, int homun_id); +typedef int (*HPMHOOK_pre_homun_gainexp) (struct homun_data **hd, unsigned int *exp); +typedef int (*HPMHOOK_post_homun_gainexp) (int retVal___, struct homun_data *hd, unsigned int exp); +typedef unsigned int (*HPMHOOK_pre_homun_add_intimacy) (struct homun_data **hd, unsigned int *value); +typedef unsigned int (*HPMHOOK_post_homun_add_intimacy) (unsigned int retVal___, struct homun_data *hd, unsigned int value); +typedef unsigned int (*HPMHOOK_pre_homun_consume_intimacy) (struct homun_data **hd, unsigned int *value); +typedef unsigned int (*HPMHOOK_post_homun_consume_intimacy) (unsigned int retVal___, struct homun_data *hd, unsigned int value); +typedef void (*HPMHOOK_pre_homun_healed) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_healed) (struct homun_data *hd); +typedef void (*HPMHOOK_pre_homun_save) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_save) (struct homun_data *hd); +typedef unsigned char (*HPMHOOK_pre_homun_menu) (struct map_session_data **sd, unsigned char *menu_num); +typedef unsigned char (*HPMHOOK_post_homun_menu) (unsigned char retVal___, struct map_session_data *sd, unsigned char menu_num); +typedef bool (*HPMHOOK_pre_homun_feed) (struct map_session_data **sd, struct homun_data **hd); +typedef bool (*HPMHOOK_post_homun_feed) (bool retVal___, struct map_session_data *sd, struct homun_data *hd); +typedef int (*HPMHOOK_pre_homun_hunger_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_homun_hunger_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_homun_hunger_timer_delete) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_hunger_timer_delete) (struct homun_data *hd); +typedef int (*HPMHOOK_pre_homun_change_name) (struct map_session_data **sd, const char **name); +typedef int (*HPMHOOK_post_homun_change_name) (int retVal___, struct map_session_data *sd, const char *name); +typedef bool (*HPMHOOK_pre_homun_change_name_ack) (struct map_session_data **sd, const char **name, int *flag); +typedef bool (*HPMHOOK_post_homun_change_name_ack) (bool retVal___, struct map_session_data *sd, const char *name, int flag); +typedef int (*HPMHOOK_pre_homun_db_search) (int *key, int *type); +typedef int (*HPMHOOK_post_homun_db_search) (int retVal___, int key, int type); +typedef bool (*HPMHOOK_pre_homun_create) (struct map_session_data **sd, const struct s_homunculus **hom); +typedef bool (*HPMHOOK_post_homun_create) (bool retVal___, struct map_session_data *sd, const struct s_homunculus *hom); +typedef void (*HPMHOOK_pre_homun_init_timers) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_init_timers) (struct homun_data *hd); +typedef bool (*HPMHOOK_pre_homun_call) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_homun_call) (bool retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_homun_recv_data) (int *account_id, const struct s_homunculus **sh, int *flag); +typedef bool (*HPMHOOK_post_homun_recv_data) (bool retVal___, int account_id, const struct s_homunculus *sh, int flag); +typedef bool (*HPMHOOK_pre_homun_creation_request) (struct map_session_data **sd, int *class_); +typedef bool (*HPMHOOK_post_homun_creation_request) (bool retVal___, struct map_session_data *sd, int class_); +typedef bool (*HPMHOOK_pre_homun_ressurect) (struct map_session_data **sd, unsigned char *per, short *x, short *y); +typedef bool (*HPMHOOK_post_homun_ressurect) (bool retVal___, struct map_session_data *sd, unsigned char per, short x, short y); +typedef void (*HPMHOOK_pre_homun_revive) (struct homun_data **hd, unsigned int *hp, unsigned int *sp); +typedef void (*HPMHOOK_post_homun_revive) (struct homun_data *hd, unsigned int hp, unsigned int sp); +typedef void (*HPMHOOK_pre_homun_stat_reset) (struct homun_data **hd); +typedef void (*HPMHOOK_post_homun_stat_reset) (struct homun_data *hd); +typedef bool (*HPMHOOK_pre_homun_shuffle) (struct homun_data **hd); +typedef bool (*HPMHOOK_post_homun_shuffle) (bool retVal___, struct homun_data *hd); +typedef bool (*HPMHOOK_pre_homun_read_db_sub) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_homun_read_db_sub) (bool retVal___, char *str[], int columns, int current); +typedef void (*HPMHOOK_pre_homun_read_db) (void); +typedef void (*HPMHOOK_post_homun_read_db) (void); +typedef bool (*HPMHOOK_pre_homun_read_skill_db_sub) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_homun_read_skill_db_sub) (bool retVal___, char *split[], int columns, int current); +typedef void (*HPMHOOK_pre_homun_skill_db_read) (void); +typedef void (*HPMHOOK_post_homun_skill_db_read) (void); +typedef void (*HPMHOOK_pre_homun_exp_db_read) (void); +typedef void (*HPMHOOK_post_homun_exp_db_read) (void); +typedef void (*HPMHOOK_pre_homun_addspiritball) (struct homun_data **hd, int *max); +typedef void (*HPMHOOK_post_homun_addspiritball) (struct homun_data *hd, int max); +typedef void (*HPMHOOK_pre_homun_delspiritball) (struct homun_data **hd, int *count, int *type); +typedef void (*HPMHOOK_post_homun_delspiritball) (struct homun_data *hd, int count, int type); +typedef int8 (*HPMHOOK_pre_homun_get_intimacy_grade) (struct homun_data **hd); +typedef int8 (*HPMHOOK_post_homun_get_intimacy_grade) (int8 retVal___, struct homun_data *hd); +#endif // MAP_HOMUNCULUS_H +#ifdef MAP_INSTANCE_H /* instance */ +typedef void (*HPMHOOK_pre_instance_init) (bool *minimal); +typedef void (*HPMHOOK_post_instance_init) (bool minimal); +typedef void (*HPMHOOK_pre_instance_final) (void); +typedef void (*HPMHOOK_post_instance_final) (void); +typedef void (*HPMHOOK_pre_instance_reload) (void); +typedef void (*HPMHOOK_post_instance_reload) (void); +typedef int (*HPMHOOK_pre_instance_create) (int *party_id, const char **name, enum instance_owner_type *type); +typedef int (*HPMHOOK_post_instance_create) (int retVal___, int party_id, const char *name, enum instance_owner_type type); +typedef int (*HPMHOOK_pre_instance_add_map) (const char **name, int *instance_id, bool *usebasename, const char **map_name); +typedef int (*HPMHOOK_post_instance_add_map) (int retVal___, const char *name, int instance_id, bool usebasename, const char *map_name); +typedef void (*HPMHOOK_pre_instance_del_map) (int16 *m); +typedef void (*HPMHOOK_post_instance_del_map) (int16 m); +typedef int (*HPMHOOK_pre_instance_map2imap) (int16 *m, int *instance_id); +typedef int (*HPMHOOK_post_instance_map2imap) (int retVal___, int16 m, int instance_id); +typedef int (*HPMHOOK_pre_instance_mapid2imapid) (int16 *m, int *instance_id); +typedef int (*HPMHOOK_post_instance_mapid2imapid) (int retVal___, int16 m, int instance_id); +typedef int (*HPMHOOK_pre_instance_mapname2imap) (const char **map_name, int *instance_id); +typedef int (*HPMHOOK_post_instance_mapname2imap) (int retVal___, const char *map_name, int instance_id); +typedef int (*HPMHOOK_pre_instance_map_npcsub) (struct block_list **bl, va_list args); +typedef int (*HPMHOOK_post_instance_map_npcsub) (int retVal___, struct block_list *bl, va_list args); +typedef int (*HPMHOOK_pre_instance_init_npc) (struct block_list **bl, va_list args); +typedef int (*HPMHOOK_post_instance_init_npc) (int retVal___, struct block_list *bl, va_list args); +typedef void (*HPMHOOK_pre_instance_destroy) (int *instance_id); +typedef void (*HPMHOOK_post_instance_destroy) (int instance_id); +typedef void (*HPMHOOK_pre_instance_start) (int *instance_id); +typedef void (*HPMHOOK_post_instance_start) (int instance_id); +typedef void (*HPMHOOK_pre_instance_check_idle) (int *instance_id); +typedef void (*HPMHOOK_post_instance_check_idle) (int instance_id); +typedef void (*HPMHOOK_pre_instance_check_kick) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_instance_check_kick) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_instance_set_timeout) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout); +typedef void (*HPMHOOK_post_instance_set_timeout) (int instance_id, unsigned int progress_timeout, unsigned int idle_timeout); +typedef bool (*HPMHOOK_pre_instance_valid) (int *instance_id); +typedef bool (*HPMHOOK_post_instance_valid) (bool retVal___, int instance_id); +typedef int (*HPMHOOK_pre_instance_destroy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_instance_destroy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +#endif // MAP_INSTANCE_H +#ifdef CHAR_INT_AUCTION_H /* inter_auction */ +typedef int (*HPMHOOK_pre_inter_auction_count) (int *char_id, bool *buy); +typedef int (*HPMHOOK_post_inter_auction_count) (int retVal___, int char_id, bool buy); +typedef void (*HPMHOOK_pre_inter_auction_save) (struct auction_data **auction); +typedef void (*HPMHOOK_post_inter_auction_save) (struct auction_data *auction); +typedef unsigned int (*HPMHOOK_pre_inter_auction_create) (struct auction_data **auction); +typedef unsigned int (*HPMHOOK_post_inter_auction_create) (unsigned int retVal___, struct auction_data *auction); +typedef int (*HPMHOOK_pre_inter_auction_end_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_inter_auction_end_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_inter_auction_delete_) (struct auction_data **auction); +typedef void (*HPMHOOK_post_inter_auction_delete_) (struct auction_data *auction); +typedef void (*HPMHOOK_pre_inter_auction_fromsql) (void); +typedef void (*HPMHOOK_post_inter_auction_fromsql) (void); +typedef int (*HPMHOOK_pre_inter_auction_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_auction_parse_frommap) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_inter_auction_sql_init) (void); +typedef int (*HPMHOOK_post_inter_auction_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_auction_sql_final) (void); +typedef void (*HPMHOOK_post_inter_auction_sql_final) (void); +#endif // CHAR_INT_AUCTION_H +#ifdef CHAR_INT_ELEMENTAL_H /* inter_elemental */ +typedef void (*HPMHOOK_pre_inter_elemental_sql_init) (void); +typedef void (*HPMHOOK_post_inter_elemental_sql_init) (void); +typedef void (*HPMHOOK_pre_inter_elemental_sql_final) (void); +typedef void (*HPMHOOK_post_inter_elemental_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_elemental_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_elemental_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_ELEMENTAL_H +#ifdef CHAR_INT_GUILD_H /* inter_guild */ +typedef int (*HPMHOOK_pre_inter_guild_save_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_inter_guild_save_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_inter_guild_removemember_tosql) (int *account_id, int *char_id); +typedef int (*HPMHOOK_post_inter_guild_removemember_tosql) (int retVal___, int account_id, int char_id); +typedef int (*HPMHOOK_pre_inter_guild_tosql) (struct guild **g, int *flag); +typedef int (*HPMHOOK_post_inter_guild_tosql) (int retVal___, struct guild *g, int flag); +typedef struct guild* (*HPMHOOK_pre_inter_guild_fromsql) (int *guild_id); +typedef struct guild* (*HPMHOOK_post_inter_guild_fromsql) (struct guild* retVal___, int guild_id); +typedef int (*HPMHOOK_pre_inter_guild_castle_tosql) (struct guild_castle **gc); +typedef int (*HPMHOOK_post_inter_guild_castle_tosql) (int retVal___, struct guild_castle *gc); +typedef struct guild_castle* (*HPMHOOK_pre_inter_guild_castle_fromsql) (int *castle_id); +typedef struct guild_castle* (*HPMHOOK_post_inter_guild_castle_fromsql) (struct guild_castle* retVal___, int castle_id); +typedef bool (*HPMHOOK_pre_inter_guild_exp_parse_row) (char **split[], int *column, int *current); +typedef bool (*HPMHOOK_post_inter_guild_exp_parse_row) (bool retVal___, char *split[], int column, int current); +typedef int (*HPMHOOK_pre_inter_guild_CharOnline) (int *char_id, int *guild_id); +typedef int (*HPMHOOK_post_inter_guild_CharOnline) (int retVal___, int char_id, int guild_id); +typedef int (*HPMHOOK_pre_inter_guild_CharOffline) (int *char_id, int *guild_id); +typedef int (*HPMHOOK_post_inter_guild_CharOffline) (int retVal___, int char_id, int guild_id); +typedef int (*HPMHOOK_pre_inter_guild_sql_init) (void); +typedef int (*HPMHOOK_post_inter_guild_sql_init) (int retVal___); +typedef int (*HPMHOOK_pre_inter_guild_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_inter_guild_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_inter_guild_sql_final) (void); +typedef void (*HPMHOOK_post_inter_guild_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_guild_search_guildname) (const char **str); +typedef int (*HPMHOOK_post_inter_guild_search_guildname) (int retVal___, const char *str); +typedef bool (*HPMHOOK_pre_inter_guild_check_empty) (struct guild **g); +typedef bool (*HPMHOOK_post_inter_guild_check_empty) (bool retVal___, struct guild *g); +typedef unsigned int (*HPMHOOK_pre_inter_guild_nextexp) (int *level); +typedef unsigned int (*HPMHOOK_post_inter_guild_nextexp) (unsigned int retVal___, int level); +typedef int (*HPMHOOK_pre_inter_guild_checkskill) (struct guild **g, int *id); +typedef int (*HPMHOOK_post_inter_guild_checkskill) (int retVal___, struct guild *g, int id); +typedef int (*HPMHOOK_pre_inter_guild_calcinfo) (struct guild **g); +typedef int (*HPMHOOK_post_inter_guild_calcinfo) (int retVal___, struct guild *g); +typedef int (*HPMHOOK_pre_inter_guild_sex_changed) (int *guild_id, int *account_id, int *char_id, short *gender); +typedef int (*HPMHOOK_post_inter_guild_sex_changed) (int retVal___, int guild_id, int account_id, int char_id, short gender); +typedef int (*HPMHOOK_pre_inter_guild_charname_changed) (int *guild_id, int *account_id, int *char_id, char **name); +typedef int (*HPMHOOK_post_inter_guild_charname_changed) (int retVal___, int guild_id, int account_id, int char_id, char *name); +typedef int (*HPMHOOK_pre_inter_guild_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_guild_parse_frommap) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_inter_guild_leave) (int *guild_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_inter_guild_leave) (int retVal___, int guild_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_inter_guild_broken) (int *guild_id); +typedef int (*HPMHOOK_post_inter_guild_broken) (int retVal___, int guild_id); +#endif // CHAR_INT_GUILD_H +#ifdef CHAR_INT_HOMUN_H /* inter_homunculus */ +typedef int (*HPMHOOK_pre_inter_homunculus_sql_init) (void); +typedef int (*HPMHOOK_post_inter_homunculus_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_homunculus_sql_final) (void); +typedef void (*HPMHOOK_post_inter_homunculus_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_homunculus_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_homunculus_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_HOMUN_H +#ifdef CHAR_INTER_H /* inter */ +typedef const char* (*HPMHOOK_pre_inter_msg_txt) (int *msg_number); +typedef const char* (*HPMHOOK_post_inter_msg_txt) (const char* retVal___, int msg_number); +typedef bool (*HPMHOOK_pre_inter_msg_config_read) (const char **cfg_name, bool *allow_override); +typedef bool (*HPMHOOK_post_inter_msg_config_read) (bool retVal___, const char *cfg_name, bool allow_override); +typedef void (*HPMHOOK_pre_inter_do_final_msg) (void); +typedef void (*HPMHOOK_post_inter_do_final_msg) (void); +typedef const char* (*HPMHOOK_pre_inter_job_name) (int *class_); +typedef const char* (*HPMHOOK_post_inter_job_name) (const char* retVal___, int class_); +typedef void (*HPMHOOK_pre_inter_vmsg_to_fd) (int *fd, int *u_fd, int *aid, char **msg, va_list ap); +typedef void (*HPMHOOK_post_inter_vmsg_to_fd) (int fd, int u_fd, int aid, char *msg, va_list ap); +typedef void (*HPMHOOK_pre_inter_savereg) (int *account_id, int *char_id, const char **key, unsigned int *index, intptr_t *val, bool *is_string); +typedef void (*HPMHOOK_post_inter_savereg) (int account_id, int char_id, const char *key, unsigned int index, intptr_t val, bool is_string); +typedef int (*HPMHOOK_pre_inter_accreg_fromsql) (int *account_id, int *char_id, int *fd, int *type); +typedef int (*HPMHOOK_post_inter_accreg_fromsql) (int retVal___, int account_id, int char_id, int fd, int type); +typedef int (*HPMHOOK_pre_inter_config_read) (const char **cfgName); +typedef int (*HPMHOOK_post_inter_config_read) (int retVal___, const char *cfgName); +typedef int (*HPMHOOK_pre_inter_vlog) (char **fmt, va_list ap); +typedef int (*HPMHOOK_post_inter_vlog) (int retVal___, char *fmt, va_list ap); +typedef int (*HPMHOOK_pre_inter_init_sql) (const char **file); +typedef int (*HPMHOOK_post_inter_init_sql) (int retVal___, const char *file); +typedef int (*HPMHOOK_pre_inter_mapif_init) (int *fd); +typedef int (*HPMHOOK_post_inter_mapif_init) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_inter_check_ttl_wisdata_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_inter_check_ttl_wisdata_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_inter_check_ttl_wisdata) (void); +typedef int (*HPMHOOK_post_inter_check_ttl_wisdata) (int retVal___); +typedef int (*HPMHOOK_pre_inter_check_length) (int *fd, int *length); +typedef int (*HPMHOOK_post_inter_check_length) (int retVal___, int fd, int length); +typedef int (*HPMHOOK_pre_inter_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_parse_frommap) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_inter_final) (void); +typedef void (*HPMHOOK_post_inter_final) (void); +#endif // CHAR_INTER_H +#ifdef CHAR_INT_MAIL_H /* inter_mail */ +typedef int (*HPMHOOK_pre_inter_mail_sql_init) (void); +typedef int (*HPMHOOK_post_inter_mail_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_mail_sql_final) (void); +typedef void (*HPMHOOK_post_inter_mail_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_mail_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_mail_parse_frommap) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_inter_mail_fromsql) (int *char_id, struct mail_data **md); +typedef int (*HPMHOOK_post_inter_mail_fromsql) (int retVal___, int char_id, struct mail_data *md); +typedef int (*HPMHOOK_pre_inter_mail_savemessage) (struct mail_message **msg); +typedef int (*HPMHOOK_post_inter_mail_savemessage) (int retVal___, struct mail_message *msg); +typedef bool (*HPMHOOK_pre_inter_mail_loadmessage) (int *mail_id, struct mail_message **msg); +typedef bool (*HPMHOOK_post_inter_mail_loadmessage) (bool retVal___, int mail_id, struct mail_message *msg); +typedef bool (*HPMHOOK_pre_inter_mail_DeleteAttach) (int *mail_id); +typedef bool (*HPMHOOK_post_inter_mail_DeleteAttach) (bool retVal___, int mail_id); +typedef void (*HPMHOOK_pre_inter_mail_sendmail) (int *send_id, const char **send_name, int *dest_id, const char **dest_name, const char **title, const char **body, int *zeny, struct item **item); +typedef void (*HPMHOOK_post_inter_mail_sendmail) (int send_id, const char *send_name, int dest_id, const char *dest_name, const char *title, const char *body, int zeny, struct item *item); +#endif // CHAR_INT_MAIL_H +#ifdef CHAR_INT_MERCENARY_H /* inter_mercenary */ +typedef bool (*HPMHOOK_pre_inter_mercenary_owner_fromsql) (int *char_id, struct mmo_charstatus **status); +typedef bool (*HPMHOOK_post_inter_mercenary_owner_fromsql) (bool retVal___, int char_id, struct mmo_charstatus *status); +typedef bool (*HPMHOOK_pre_inter_mercenary_owner_tosql) (int *char_id, struct mmo_charstatus **status); +typedef bool (*HPMHOOK_post_inter_mercenary_owner_tosql) (bool retVal___, int char_id, struct mmo_charstatus *status); +typedef bool (*HPMHOOK_pre_inter_mercenary_owner_delete) (int *char_id); +typedef bool (*HPMHOOK_post_inter_mercenary_owner_delete) (bool retVal___, int char_id); +typedef int (*HPMHOOK_pre_inter_mercenary_sql_init) (void); +typedef int (*HPMHOOK_post_inter_mercenary_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_mercenary_sql_final) (void); +typedef void (*HPMHOOK_post_inter_mercenary_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_mercenary_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_mercenary_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_MERCENARY_H +#ifdef CHAR_INT_PARTY_H /* inter_party */ +typedef int (*HPMHOOK_pre_inter_party_check_lv) (struct party_data **p); +typedef int (*HPMHOOK_post_inter_party_check_lv) (int retVal___, struct party_data *p); +typedef void (*HPMHOOK_pre_inter_party_calc_state) (struct party_data **p); +typedef void (*HPMHOOK_post_inter_party_calc_state) (struct party_data *p); +typedef int (*HPMHOOK_pre_inter_party_tosql) (struct party **p, int *flag, int *index); +typedef int (*HPMHOOK_post_inter_party_tosql) (int retVal___, struct party *p, int flag, int index); +typedef struct party_data* (*HPMHOOK_pre_inter_party_fromsql) (int *party_id); +typedef struct party_data* (*HPMHOOK_post_inter_party_fromsql) (struct party_data* retVal___, int party_id); +typedef int (*HPMHOOK_pre_inter_party_sql_init) (void); +typedef int (*HPMHOOK_post_inter_party_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_party_sql_final) (void); +typedef void (*HPMHOOK_post_inter_party_sql_final) (void); +typedef struct party_data* (*HPMHOOK_pre_inter_party_search_partyname) (const char **str); +typedef struct party_data* (*HPMHOOK_post_inter_party_search_partyname) (struct party_data* retVal___, const char *str); +typedef int (*HPMHOOK_pre_inter_party_check_exp_share) (struct party_data **p); +typedef int (*HPMHOOK_post_inter_party_check_exp_share) (int retVal___, struct party_data *p); +typedef int (*HPMHOOK_pre_inter_party_check_empty) (struct party_data **p); +typedef int (*HPMHOOK_post_inter_party_check_empty) (int retVal___, struct party_data *p); +typedef int (*HPMHOOK_pre_inter_party_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_party_parse_frommap) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_inter_party_leave) (int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_inter_party_leave) (int retVal___, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_inter_party_CharOnline) (int *char_id, int *party_id); +typedef int (*HPMHOOK_post_inter_party_CharOnline) (int retVal___, int char_id, int party_id); +typedef int (*HPMHOOK_pre_inter_party_CharOffline) (int *char_id, int *party_id); +typedef int (*HPMHOOK_post_inter_party_CharOffline) (int retVal___, int char_id, int party_id); +#endif // CHAR_INT_PARTY_H +#ifdef CHAR_INT_PET_H /* inter_pet */ +typedef int (*HPMHOOK_pre_inter_pet_tosql) (const struct s_pet **p); +typedef int (*HPMHOOK_post_inter_pet_tosql) (int retVal___, const struct s_pet *p); +typedef int (*HPMHOOK_pre_inter_pet_fromsql) (int *pet_id, struct s_pet **p); +typedef int (*HPMHOOK_post_inter_pet_fromsql) (int retVal___, int pet_id, struct s_pet *p); +typedef int (*HPMHOOK_pre_inter_pet_sql_init) (void); +typedef int (*HPMHOOK_post_inter_pet_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_pet_sql_final) (void); +typedef void (*HPMHOOK_post_inter_pet_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_pet_delete_) (int *pet_id); +typedef int (*HPMHOOK_post_inter_pet_delete_) (int retVal___, int pet_id); +typedef int (*HPMHOOK_pre_inter_pet_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_pet_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_PET_H +#ifdef CHAR_INT_QUEST_H /* inter_quest */ +typedef int (*HPMHOOK_pre_inter_quest_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_quest_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_QUEST_H +#ifdef CHAR_INT_STORAGE_H /* inter_storage */ +typedef int (*HPMHOOK_pre_inter_storage_tosql) (int *account_id, struct storage_data **p); +typedef int (*HPMHOOK_post_inter_storage_tosql) (int retVal___, int account_id, struct storage_data *p); +typedef int (*HPMHOOK_pre_inter_storage_fromsql) (int *account_id, struct storage_data **p); +typedef int (*HPMHOOK_post_inter_storage_fromsql) (int retVal___, int account_id, struct storage_data *p); +typedef int (*HPMHOOK_pre_inter_storage_guild_storage_tosql) (int *guild_id, const struct guild_storage **p); +typedef int (*HPMHOOK_post_inter_storage_guild_storage_tosql) (int retVal___, int guild_id, const struct guild_storage *p); +typedef int (*HPMHOOK_pre_inter_storage_guild_storage_fromsql) (int *guild_id, struct guild_storage **p); +typedef int (*HPMHOOK_post_inter_storage_guild_storage_fromsql) (int retVal___, int guild_id, struct guild_storage *p); +typedef int (*HPMHOOK_pre_inter_storage_sql_init) (void); +typedef int (*HPMHOOK_post_inter_storage_sql_init) (int retVal___); +typedef void (*HPMHOOK_pre_inter_storage_sql_final) (void); +typedef void (*HPMHOOK_post_inter_storage_sql_final) (void); +typedef int (*HPMHOOK_pre_inter_storage_delete_) (int *account_id); +typedef int (*HPMHOOK_post_inter_storage_delete_) (int retVal___, int account_id); +typedef int (*HPMHOOK_pre_inter_storage_guild_storage_delete) (int *guild_id); +typedef int (*HPMHOOK_post_inter_storage_guild_storage_delete) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_inter_storage_parse_frommap) (int *fd); +typedef int (*HPMHOOK_post_inter_storage_parse_frommap) (int retVal___, int fd); +#endif // CHAR_INT_STORAGE_H +#ifdef MAP_INTIF_H /* intif */ +typedef int (*HPMHOOK_pre_intif_parse) (int *fd); +typedef int (*HPMHOOK_post_intif_parse) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_intif_create_pet) (int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, char **pet_name); +typedef int (*HPMHOOK_post_intif_create_pet) (int retVal___, int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, char *pet_name); +typedef int (*HPMHOOK_pre_intif_broadcast) (const char **mes, int *len, int *type); +typedef int (*HPMHOOK_post_intif_broadcast) (int retVal___, const char *mes, int len, int type); +typedef int (*HPMHOOK_pre_intif_broadcast2) (const char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY); +typedef int (*HPMHOOK_post_intif_broadcast2) (int retVal___, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY); +typedef int (*HPMHOOK_pre_intif_main_message) (struct map_session_data **sd, const char **message); +typedef int (*HPMHOOK_post_intif_main_message) (int retVal___, struct map_session_data *sd, const char *message); +typedef int (*HPMHOOK_pre_intif_wis_message) (struct map_session_data **sd, const char **nick, const char **mes, int *mes_len); +typedef int (*HPMHOOK_post_intif_wis_message) (int retVal___, struct map_session_data *sd, const char *nick, const char *mes, int mes_len); +typedef int (*HPMHOOK_pre_intif_wis_message_to_gm) (char **Wisp_name, int *permission, char **mes); +typedef int (*HPMHOOK_post_intif_wis_message_to_gm) (int retVal___, char *Wisp_name, int permission, char *mes); +typedef int (*HPMHOOK_pre_intif_saveregistry) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_intif_saveregistry) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_intif_request_registry) (struct map_session_data **sd, int *flag); +typedef int (*HPMHOOK_post_intif_request_registry) (int retVal___, struct map_session_data *sd, int flag); +typedef int (*HPMHOOK_pre_intif_request_guild_storage) (int *account_id, int *guild_id); +typedef int (*HPMHOOK_post_intif_request_guild_storage) (int retVal___, int account_id, int guild_id); +typedef int (*HPMHOOK_pre_intif_send_guild_storage) (int *account_id, struct guild_storage **gstor); +typedef int (*HPMHOOK_post_intif_send_guild_storage) (int retVal___, int account_id, struct guild_storage *gstor); +typedef int (*HPMHOOK_pre_intif_create_party) (struct party_member **member, const char **name, int *item, int *item2); +typedef int (*HPMHOOK_post_intif_create_party) (int retVal___, struct party_member *member, const char *name, int item, int item2); +typedef int (*HPMHOOK_pre_intif_request_partyinfo) (int *party_id, int *char_id); +typedef int (*HPMHOOK_post_intif_request_partyinfo) (int retVal___, int party_id, int char_id); +typedef int (*HPMHOOK_pre_intif_party_addmember) (int *party_id, struct party_member **member); +typedef int (*HPMHOOK_post_intif_party_addmember) (int retVal___, int party_id, struct party_member *member); +typedef int (*HPMHOOK_pre_intif_party_changeoption) (int *party_id, int *account_id, int *exp, int *item); +typedef int (*HPMHOOK_post_intif_party_changeoption) (int retVal___, int party_id, int account_id, int exp, int item); +typedef int (*HPMHOOK_pre_intif_party_leave) (int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_intif_party_leave) (int retVal___, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_intif_party_changemap) (struct map_session_data **sd, int *online); +typedef int (*HPMHOOK_post_intif_party_changemap) (int retVal___, struct map_session_data *sd, int online); +typedef int (*HPMHOOK_pre_intif_break_party) (int *party_id); +typedef int (*HPMHOOK_post_intif_break_party) (int retVal___, int party_id); +typedef int (*HPMHOOK_pre_intif_party_message) (int *party_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_intif_party_message) (int retVal___, int party_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_intif_party_leaderchange) (int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_intif_party_leaderchange) (int retVal___, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_intif_guild_create) (const char **name, const struct guild_member **master); +typedef int (*HPMHOOK_post_intif_guild_create) (int retVal___, const char *name, const struct guild_member *master); +typedef int (*HPMHOOK_pre_intif_guild_request_info) (int *guild_id); +typedef int (*HPMHOOK_post_intif_guild_request_info) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_intif_guild_addmember) (int *guild_id, struct guild_member **m); +typedef int (*HPMHOOK_post_intif_guild_addmember) (int retVal___, int guild_id, struct guild_member *m); +typedef int (*HPMHOOK_pre_intif_guild_leave) (int *guild_id, int *account_id, int *char_id, int *flag, const char **mes); +typedef int (*HPMHOOK_post_intif_guild_leave) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *mes); +typedef int (*HPMHOOK_pre_intif_guild_memberinfoshort) (int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); +typedef int (*HPMHOOK_post_intif_guild_memberinfoshort) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_); +typedef int (*HPMHOOK_pre_intif_guild_break) (int *guild_id); +typedef int (*HPMHOOK_post_intif_guild_break) (int retVal___, int guild_id); +typedef int (*HPMHOOK_pre_intif_guild_message) (int *guild_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_intif_guild_message) (int retVal___, int guild_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_intif_guild_change_gm) (int *guild_id, const char **name, int *len); +typedef int (*HPMHOOK_post_intif_guild_change_gm) (int retVal___, int guild_id, const char *name, int len); +typedef int (*HPMHOOK_pre_intif_guild_change_basicinfo) (int *guild_id, int *type, const void **data, int *len); +typedef int (*HPMHOOK_post_intif_guild_change_basicinfo) (int retVal___, int guild_id, int type, const void *data, int len); +typedef int (*HPMHOOK_pre_intif_guild_change_memberinfo) (int *guild_id, int *account_id, int *char_id, int *type, const void **data, int *len); +typedef int (*HPMHOOK_post_intif_guild_change_memberinfo) (int retVal___, int guild_id, int account_id, int char_id, int type, const void *data, int len); +typedef int (*HPMHOOK_pre_intif_guild_position) (int *guild_id, int *idx, struct guild_position **p); +typedef int (*HPMHOOK_post_intif_guild_position) (int retVal___, int guild_id, int idx, struct guild_position *p); +typedef int (*HPMHOOK_pre_intif_guild_skillup) (int *guild_id, uint16 *skill_id, int *account_id, int *max); +typedef int (*HPMHOOK_post_intif_guild_skillup) (int retVal___, int guild_id, uint16 skill_id, int account_id, int max); +typedef int (*HPMHOOK_pre_intif_guild_alliance) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag); +typedef int (*HPMHOOK_post_intif_guild_alliance) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag); +typedef int (*HPMHOOK_pre_intif_guild_notice) (int *guild_id, const char **mes1, const char **mes2); +typedef int (*HPMHOOK_post_intif_guild_notice) (int retVal___, int guild_id, const char *mes1, const char *mes2); +typedef int (*HPMHOOK_pre_intif_guild_emblem) (int *guild_id, int *len, const char **data); +typedef int (*HPMHOOK_post_intif_guild_emblem) (int retVal___, int guild_id, int len, const char *data); +typedef int (*HPMHOOK_pre_intif_guild_castle_dataload) (int *num, int **castle_ids); +typedef int (*HPMHOOK_post_intif_guild_castle_dataload) (int retVal___, int num, int *castle_ids); +typedef int (*HPMHOOK_pre_intif_guild_castle_datasave) (int *castle_id, int *index, int *value); +typedef int (*HPMHOOK_post_intif_guild_castle_datasave) (int retVal___, int castle_id, int index, int value); +typedef void (*HPMHOOK_pre_intif_itembound_req) (int *char_id, int *aid, int *guild_id); +typedef void (*HPMHOOK_post_intif_itembound_req) (int char_id, int aid, int guild_id); +typedef int (*HPMHOOK_pre_intif_request_petdata) (int *account_id, int *char_id, int *pet_id); +typedef int (*HPMHOOK_post_intif_request_petdata) (int retVal___, int account_id, int char_id, int pet_id); +typedef int (*HPMHOOK_pre_intif_save_petdata) (int *account_id, struct s_pet **p); +typedef int (*HPMHOOK_post_intif_save_petdata) (int retVal___, int account_id, struct s_pet *p); +typedef int (*HPMHOOK_pre_intif_delete_petdata) (int *pet_id); +typedef int (*HPMHOOK_post_intif_delete_petdata) (int retVal___, int pet_id); +typedef int (*HPMHOOK_pre_intif_rename) (struct map_session_data **sd, int *type, const char **name); +typedef int (*HPMHOOK_post_intif_rename) (int retVal___, struct map_session_data *sd, int type, const char *name); +typedef int (*HPMHOOK_pre_intif_homunculus_create) (int *account_id, struct s_homunculus **sh); +typedef int (*HPMHOOK_post_intif_homunculus_create) (int retVal___, int account_id, struct s_homunculus *sh); +typedef bool (*HPMHOOK_pre_intif_homunculus_requestload) (int *account_id, int *homun_id); +typedef bool (*HPMHOOK_post_intif_homunculus_requestload) (bool retVal___, int account_id, int homun_id); +typedef int (*HPMHOOK_pre_intif_homunculus_requestsave) (int *account_id, struct s_homunculus **sh); +typedef int (*HPMHOOK_post_intif_homunculus_requestsave) (int retVal___, int account_id, struct s_homunculus *sh); +typedef int (*HPMHOOK_pre_intif_homunculus_requestdelete) (int *homun_id); +typedef int (*HPMHOOK_post_intif_homunculus_requestdelete) (int retVal___, int homun_id); +typedef void (*HPMHOOK_pre_intif_request_questlog) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_intif_request_questlog) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_intif_quest_save) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_intif_quest_save) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_intif_mercenary_create) (struct s_mercenary **merc); +typedef int (*HPMHOOK_post_intif_mercenary_create) (int retVal___, struct s_mercenary *merc); +typedef int (*HPMHOOK_pre_intif_mercenary_request) (int *merc_id, int *char_id); +typedef int (*HPMHOOK_post_intif_mercenary_request) (int retVal___, int merc_id, int char_id); +typedef int (*HPMHOOK_pre_intif_mercenary_delete) (int *merc_id); +typedef int (*HPMHOOK_post_intif_mercenary_delete) (int retVal___, int merc_id); +typedef int (*HPMHOOK_pre_intif_mercenary_save) (struct s_mercenary **merc); +typedef int (*HPMHOOK_post_intif_mercenary_save) (int retVal___, struct s_mercenary *merc); +typedef int (*HPMHOOK_pre_intif_Mail_requestinbox) (int *char_id, unsigned char *flag); +typedef int (*HPMHOOK_post_intif_Mail_requestinbox) (int retVal___, int char_id, unsigned char flag); +typedef int (*HPMHOOK_pre_intif_Mail_read) (int *mail_id); +typedef int (*HPMHOOK_post_intif_Mail_read) (int retVal___, int mail_id); +typedef int (*HPMHOOK_pre_intif_Mail_getattach) (int *char_id, int *mail_id); +typedef int (*HPMHOOK_post_intif_Mail_getattach) (int retVal___, int char_id, int mail_id); +typedef int (*HPMHOOK_pre_intif_Mail_delete) (int *char_id, int *mail_id); +typedef int (*HPMHOOK_post_intif_Mail_delete) (int retVal___, int char_id, int mail_id); +typedef int (*HPMHOOK_pre_intif_Mail_return) (int *char_id, int *mail_id); +typedef int (*HPMHOOK_post_intif_Mail_return) (int retVal___, int char_id, int mail_id); +typedef int (*HPMHOOK_pre_intif_Mail_send) (int *account_id, struct mail_message **msg); +typedef int (*HPMHOOK_post_intif_Mail_send) (int retVal___, int account_id, struct mail_message *msg); +typedef int (*HPMHOOK_pre_intif_Auction_requestlist) (int *char_id, short *type, int *price, const char **searchtext, short *page); +typedef int (*HPMHOOK_post_intif_Auction_requestlist) (int retVal___, int char_id, short type, int price, const char *searchtext, short page); +typedef int (*HPMHOOK_pre_intif_Auction_register) (struct auction_data **auction); +typedef int (*HPMHOOK_post_intif_Auction_register) (int retVal___, struct auction_data *auction); +typedef int (*HPMHOOK_pre_intif_Auction_cancel) (int *char_id, unsigned int *auction_id); +typedef int (*HPMHOOK_post_intif_Auction_cancel) (int retVal___, int char_id, unsigned int auction_id); +typedef int (*HPMHOOK_pre_intif_Auction_close) (int *char_id, unsigned int *auction_id); +typedef int (*HPMHOOK_post_intif_Auction_close) (int retVal___, int char_id, unsigned int auction_id); +typedef int (*HPMHOOK_pre_intif_Auction_bid) (int *char_id, const char **name, unsigned int *auction_id, int *bid); +typedef int (*HPMHOOK_post_intif_Auction_bid) (int retVal___, int char_id, const char *name, unsigned int auction_id, int bid); +typedef int (*HPMHOOK_pre_intif_elemental_create) (struct s_elemental **ele); +typedef int (*HPMHOOK_post_intif_elemental_create) (int retVal___, struct s_elemental *ele); +typedef int (*HPMHOOK_pre_intif_elemental_request) (int *ele_id, int *char_id); +typedef int (*HPMHOOK_post_intif_elemental_request) (int retVal___, int ele_id, int char_id); +typedef int (*HPMHOOK_pre_intif_elemental_delete) (int *ele_id); +typedef int (*HPMHOOK_post_intif_elemental_delete) (int retVal___, int ele_id); +typedef int (*HPMHOOK_pre_intif_elemental_save) (struct s_elemental **ele); +typedef int (*HPMHOOK_post_intif_elemental_save) (int retVal___, struct s_elemental *ele); +typedef void (*HPMHOOK_pre_intif_request_accinfo) (int *u_fd, int *aid, int *group_lv, char **query); +typedef void (*HPMHOOK_post_intif_request_accinfo) (int u_fd, int aid, int group_lv, char *query); +typedef int (*HPMHOOK_pre_intif_CheckForCharServer) (void); +typedef int (*HPMHOOK_post_intif_CheckForCharServer) (int retVal___); +typedef void (*HPMHOOK_pre_intif_pWisMessage) (int *fd); +typedef void (*HPMHOOK_post_intif_pWisMessage) (int fd); +typedef void (*HPMHOOK_pre_intif_pWisEnd) (int *fd); +typedef void (*HPMHOOK_post_intif_pWisEnd) (int fd); +typedef int (*HPMHOOK_pre_intif_pWisToGM_sub) (struct map_session_data **sd, va_list va); +typedef int (*HPMHOOK_post_intif_pWisToGM_sub) (int retVal___, struct map_session_data *sd, va_list va); +typedef void (*HPMHOOK_pre_intif_pWisToGM) (int *fd); +typedef void (*HPMHOOK_post_intif_pWisToGM) (int fd); +typedef void (*HPMHOOK_pre_intif_pRegisters) (int *fd); +typedef void (*HPMHOOK_post_intif_pRegisters) (int fd); +typedef void (*HPMHOOK_pre_intif_pChangeNameOk) (int *fd); +typedef void (*HPMHOOK_post_intif_pChangeNameOk) (int fd); +typedef void (*HPMHOOK_pre_intif_pMessageToFD) (int *fd); +typedef void (*HPMHOOK_post_intif_pMessageToFD) (int fd); +typedef void (*HPMHOOK_pre_intif_pLoadGuildStorage) (int *fd); +typedef void (*HPMHOOK_post_intif_pLoadGuildStorage) (int fd); +typedef void (*HPMHOOK_pre_intif_pSaveGuildStorage) (int *fd); +typedef void (*HPMHOOK_post_intif_pSaveGuildStorage) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyCreated) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyCreated) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyInfo) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyInfo) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyMemberAdded) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyMemberAdded) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyOptionChanged) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyOptionChanged) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyMemberWithdraw) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyMemberWithdraw) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyMove) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyMove) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyBroken) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyBroken) (int fd); +typedef void (*HPMHOOK_pre_intif_pPartyMessage) (int *fd); +typedef void (*HPMHOOK_post_intif_pPartyMessage) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildCreated) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildCreated) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildInfo) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildInfo) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMemberAdded) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMemberAdded) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMemberWithdraw) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMemberWithdraw) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMemberInfoShort) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMemberInfoShort) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildBroken) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildBroken) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMessage) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMessage) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildBasicInfoChanged) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildBasicInfoChanged) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMemberInfoChanged) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMemberInfoChanged) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildPosition) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildPosition) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildSkillUp) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildSkillUp) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildAlliance) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildAlliance) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildNotice) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildNotice) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildEmblem) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildEmblem) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildCastleDataLoad) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildCastleDataLoad) (int fd); +typedef void (*HPMHOOK_pre_intif_pGuildMasterChanged) (int *fd); +typedef void (*HPMHOOK_post_intif_pGuildMasterChanged) (int fd); +typedef void (*HPMHOOK_pre_intif_pQuestLog) (int *fd); +typedef void (*HPMHOOK_post_intif_pQuestLog) (int fd); +typedef void (*HPMHOOK_pre_intif_pQuestSave) (int *fd); +typedef void (*HPMHOOK_post_intif_pQuestSave) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailInboxReceived) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailInboxReceived) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailNew) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailNew) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailGetAttach) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailGetAttach) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailDelete) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailDelete) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailReturn) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailReturn) (int fd); +typedef void (*HPMHOOK_pre_intif_pMailSend) (int *fd); +typedef void (*HPMHOOK_post_intif_pMailSend) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionResults) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionResults) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionRegister) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionRegister) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionCancel) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionCancel) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionClose) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionClose) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionMessage) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionMessage) (int fd); +typedef void (*HPMHOOK_pre_intif_pAuctionBid) (int *fd); +typedef void (*HPMHOOK_post_intif_pAuctionBid) (int fd); +typedef void (*HPMHOOK_pre_intif_pItembound_ack) (int *fd); +typedef void (*HPMHOOK_post_intif_pItembound_ack) (int fd); +typedef void (*HPMHOOK_pre_intif_pMercenaryReceived) (int *fd); +typedef void (*HPMHOOK_post_intif_pMercenaryReceived) (int fd); +typedef void (*HPMHOOK_pre_intif_pMercenaryDeleted) (int *fd); +typedef void (*HPMHOOK_post_intif_pMercenaryDeleted) (int fd); +typedef void (*HPMHOOK_pre_intif_pMercenarySaved) (int *fd); +typedef void (*HPMHOOK_post_intif_pMercenarySaved) (int fd); +typedef void (*HPMHOOK_pre_intif_pElementalReceived) (int *fd); +typedef void (*HPMHOOK_post_intif_pElementalReceived) (int fd); +typedef void (*HPMHOOK_pre_intif_pElementalDeleted) (int *fd); +typedef void (*HPMHOOK_post_intif_pElementalDeleted) (int fd); +typedef void (*HPMHOOK_pre_intif_pElementalSaved) (int *fd); +typedef void (*HPMHOOK_post_intif_pElementalSaved) (int fd); +typedef void (*HPMHOOK_pre_intif_pCreatePet) (int *fd); +typedef void (*HPMHOOK_post_intif_pCreatePet) (int fd); +typedef void (*HPMHOOK_pre_intif_pRecvPetData) (int *fd); +typedef void (*HPMHOOK_post_intif_pRecvPetData) (int fd); +typedef void (*HPMHOOK_pre_intif_pSavePetOk) (int *fd); +typedef void (*HPMHOOK_post_intif_pSavePetOk) (int fd); +typedef void (*HPMHOOK_pre_intif_pDeletePetOk) (int *fd); +typedef void (*HPMHOOK_post_intif_pDeletePetOk) (int fd); +typedef void (*HPMHOOK_pre_intif_pCreateHomunculus) (int *fd); +typedef void (*HPMHOOK_post_intif_pCreateHomunculus) (int fd); +typedef void (*HPMHOOK_pre_intif_pRecvHomunculusData) (int *fd); +typedef void (*HPMHOOK_post_intif_pRecvHomunculusData) (int fd); +typedef void (*HPMHOOK_pre_intif_pSaveHomunculusOk) (int *fd); +typedef void (*HPMHOOK_post_intif_pSaveHomunculusOk) (int fd); +typedef void (*HPMHOOK_pre_intif_pDeleteHomunculusOk) (int *fd); +typedef void (*HPMHOOK_post_intif_pDeleteHomunculusOk) (int fd); +#endif // MAP_INTIF_H +#ifdef MAP_IRC_BOT_H /* ircbot */ +typedef void (*HPMHOOK_pre_ircbot_init) (bool *minimal); +typedef void (*HPMHOOK_post_ircbot_init) (bool minimal); +typedef void (*HPMHOOK_pre_ircbot_final) (void); +typedef void (*HPMHOOK_post_ircbot_final) (void); +typedef int (*HPMHOOK_pre_ircbot_parse) (int *fd); +typedef int (*HPMHOOK_post_ircbot_parse) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_ircbot_parse_sub) (int *fd, char **str); +typedef void (*HPMHOOK_post_ircbot_parse_sub) (int fd, char *str); +typedef void (*HPMHOOK_pre_ircbot_parse_source) (char **source, char **nick, char **ident, char **host); +typedef void (*HPMHOOK_post_ircbot_parse_source) (char *source, char *nick, char *ident, char *host); +typedef struct irc_func* (*HPMHOOK_pre_ircbot_func_search) (char **function_name); +typedef struct irc_func* (*HPMHOOK_post_ircbot_func_search) (struct irc_func* retVal___, char *function_name); +typedef int (*HPMHOOK_pre_ircbot_connect_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_ircbot_connect_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_ircbot_identify_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_ircbot_identify_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_ircbot_join_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_ircbot_join_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_ircbot_queue_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_ircbot_queue_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_ircbot_queue) (char **str); +typedef void (*HPMHOOK_post_ircbot_queue) (char *str); +typedef void (*HPMHOOK_pre_ircbot_send) (char **str, bool *force); +typedef void (*HPMHOOK_post_ircbot_send) (char *str, bool force); +typedef void (*HPMHOOK_pre_ircbot_relay) (const char **name, const char **msg); +typedef void (*HPMHOOK_post_ircbot_relay) (const char *name, const char *msg); +typedef void (*HPMHOOK_pre_ircbot_pong) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_pong) (int fd, char *cmd, char *source, char *target, char *msg); +typedef void (*HPMHOOK_pre_ircbot_privmsg) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_privmsg) (int fd, char *cmd, char *source, char *target, char *msg); +typedef void (*HPMHOOK_pre_ircbot_privmsg_ctcp) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_privmsg_ctcp) (int fd, char *cmd, char *source, char *target, char *msg); +typedef void (*HPMHOOK_pre_ircbot_userjoin) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_userjoin) (int fd, char *cmd, char *source, char *target, char *msg); +typedef void (*HPMHOOK_pre_ircbot_userleave) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_userleave) (int fd, char *cmd, char *source, char *target, char *msg); +typedef void (*HPMHOOK_pre_ircbot_usernick) (int *fd, char **cmd, char **source, char **target, char **msg); +typedef void (*HPMHOOK_post_ircbot_usernick) (int fd, char *cmd, char *source, char *target, char *msg); +#endif // MAP_IRC_BOT_H +#ifdef MAP_ITEMDB_H /* itemdb */ +typedef void (*HPMHOOK_pre_itemdb_init) (bool *minimal); +typedef void (*HPMHOOK_post_itemdb_init) (bool minimal); +typedef void (*HPMHOOK_pre_itemdb_final) (void); +typedef void (*HPMHOOK_post_itemdb_final) (void); +typedef void (*HPMHOOK_pre_itemdb_reload) (void); +typedef void (*HPMHOOK_post_itemdb_reload) (void); +typedef void (*HPMHOOK_pre_itemdb_name_constants) (void); +typedef void (*HPMHOOK_post_itemdb_name_constants) (void); +typedef void (*HPMHOOK_pre_itemdb_read_groups) (void); +typedef void (*HPMHOOK_post_itemdb_read_groups) (void); +typedef void (*HPMHOOK_pre_itemdb_read_chains) (void); +typedef void (*HPMHOOK_post_itemdb_read_chains) (void); +typedef void (*HPMHOOK_pre_itemdb_read_packages) (void); +typedef void (*HPMHOOK_post_itemdb_read_packages) (void); +typedef void (*HPMHOOK_pre_itemdb_write_cached_packages) (const char **config_filename); +typedef void (*HPMHOOK_post_itemdb_write_cached_packages) (const char *config_filename); +typedef bool (*HPMHOOK_pre_itemdb_read_cached_packages) (const char **config_filename); +typedef bool (*HPMHOOK_post_itemdb_read_cached_packages) (bool retVal___, const char *config_filename); +typedef struct item_data* (*HPMHOOK_pre_itemdb_name2id) (const char **str); +typedef struct item_data* (*HPMHOOK_post_itemdb_name2id) (struct item_data* retVal___, const char *str); +typedef struct item_data* (*HPMHOOK_pre_itemdb_search_name) (const char **name); +typedef struct item_data* (*HPMHOOK_post_itemdb_search_name) (struct item_data* retVal___, const char *name); +typedef int (*HPMHOOK_pre_itemdb_search_name_array) (struct item_data ***data, int *size, const char **str, int *flag); +typedef int (*HPMHOOK_post_itemdb_search_name_array) (int retVal___, struct item_data **data, int size, const char *str, int flag); +typedef struct item_data* (*HPMHOOK_pre_itemdb_load) (int *nameid); +typedef struct item_data* (*HPMHOOK_post_itemdb_load) (struct item_data* retVal___, int nameid); +typedef struct item_data* (*HPMHOOK_pre_itemdb_search) (int *nameid); +typedef struct item_data* (*HPMHOOK_post_itemdb_search) (struct item_data* retVal___, int nameid); +typedef struct item_data* (*HPMHOOK_pre_itemdb_exists) (int *nameid); +typedef struct item_data* (*HPMHOOK_post_itemdb_exists) (struct item_data* retVal___, int nameid); +typedef bool (*HPMHOOK_pre_itemdb_in_group) (struct item_group **group, int *nameid); +typedef bool (*HPMHOOK_post_itemdb_in_group) (bool retVal___, struct item_group *group, int nameid); +typedef int (*HPMHOOK_pre_itemdb_group_item) (struct item_group **group); +typedef int (*HPMHOOK_post_itemdb_group_item) (int retVal___, struct item_group *group); +typedef int (*HPMHOOK_pre_itemdb_chain_item) (unsigned short *chain_id, int **rate); +typedef int (*HPMHOOK_post_itemdb_chain_item) (int retVal___, unsigned short chain_id, int *rate); +typedef void (*HPMHOOK_pre_itemdb_package_item) (struct map_session_data **sd, struct item_package **package); +typedef void (*HPMHOOK_post_itemdb_package_item) (struct map_session_data *sd, struct item_package *package); +typedef int (*HPMHOOK_pre_itemdb_searchname_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_itemdb_searchname_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_itemdb_searchname_array_sub) (union DBKey *key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_post_itemdb_searchname_array_sub) (int retVal___, union DBKey key, struct DBData data, va_list ap); +typedef int (*HPMHOOK_pre_itemdb_searchrandomid) (struct item_group **group); +typedef int (*HPMHOOK_post_itemdb_searchrandomid) (int retVal___, struct item_group *group); +typedef const char* (*HPMHOOK_pre_itemdb_typename) (int *type); +typedef const char* (*HPMHOOK_post_itemdb_typename) (const char* retVal___, int type); +typedef void (*HPMHOOK_pre_itemdb_jobmask2mapid) (uint64 **bclass, uint64 *jobmask); +typedef void (*HPMHOOK_post_itemdb_jobmask2mapid) (uint64 *bclass, uint64 jobmask); +typedef void (*HPMHOOK_pre_itemdb_jobid2mapid) (uint64 **bclass, int *job_id, bool *enable); +typedef void (*HPMHOOK_post_itemdb_jobid2mapid) (uint64 *bclass, int job_id, bool enable); +typedef void (*HPMHOOK_pre_itemdb_create_dummy_data) (void); +typedef void (*HPMHOOK_post_itemdb_create_dummy_data) (void); +typedef struct item_data* (*HPMHOOK_pre_itemdb_create_item_data) (int *nameid); +typedef struct item_data* (*HPMHOOK_post_itemdb_create_item_data) (struct item_data* retVal___, int nameid); +typedef int (*HPMHOOK_pre_itemdb_isequip) (int *nameid); +typedef int (*HPMHOOK_post_itemdb_isequip) (int retVal___, int nameid); +typedef int (*HPMHOOK_pre_itemdb_isequip2) (struct item_data **data); +typedef int (*HPMHOOK_post_itemdb_isequip2) (int retVal___, struct item_data *data); +typedef int (*HPMHOOK_pre_itemdb_isstackable) (int *nameid); +typedef int (*HPMHOOK_post_itemdb_isstackable) (int retVal___, int nameid); +typedef int (*HPMHOOK_pre_itemdb_isstackable2) (struct item_data **data); +typedef int (*HPMHOOK_post_itemdb_isstackable2) (int retVal___, struct item_data *data); +typedef int (*HPMHOOK_pre_itemdb_isdropable_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_isdropable_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_cantrade_sub) (struct item_data **item, int *gmlv, int *gmlv2); +typedef int (*HPMHOOK_post_itemdb_cantrade_sub) (int retVal___, struct item_data *item, int gmlv, int gmlv2); +typedef int (*HPMHOOK_pre_itemdb_canpartnertrade_sub) (struct item_data **item, int *gmlv, int *gmlv2); +typedef int (*HPMHOOK_post_itemdb_canpartnertrade_sub) (int retVal___, struct item_data *item, int gmlv, int gmlv2); +typedef int (*HPMHOOK_pre_itemdb_cansell_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_cansell_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_cancartstore_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_cancartstore_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_canstore_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_canstore_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_canguildstore_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_canguildstore_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_canmail_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_canmail_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_canauction_sub) (struct item_data **item, int *gmlv, int *unused); +typedef int (*HPMHOOK_post_itemdb_canauction_sub) (int retVal___, struct item_data *item, int gmlv, int unused); +typedef int (*HPMHOOK_pre_itemdb_isrestricted) (struct item **item, int *gmlv, int *gmlv2, int ( **func ) (struct item_data *, int, int)); +typedef int (*HPMHOOK_post_itemdb_isrestricted) (int retVal___, struct item *item, int gmlv, int gmlv2, int ( *func ) (struct item_data *, int, int)); +typedef int (*HPMHOOK_pre_itemdb_isidentified) (int *nameid); +typedef int (*HPMHOOK_post_itemdb_isidentified) (int retVal___, int nameid); +typedef int (*HPMHOOK_pre_itemdb_isidentified2) (struct item_data **data); +typedef int (*HPMHOOK_post_itemdb_isidentified2) (int retVal___, struct item_data *data); +typedef int (*HPMHOOK_pre_itemdb_combo_split_atoi) (char **str, int **val); +typedef int (*HPMHOOK_post_itemdb_combo_split_atoi) (int retVal___, char *str, int *val); +typedef void (*HPMHOOK_pre_itemdb_read_combos) (void); +typedef void (*HPMHOOK_post_itemdb_read_combos) (void); +typedef int (*HPMHOOK_pre_itemdb_gendercheck) (struct item_data **id); +typedef int (*HPMHOOK_post_itemdb_gendercheck) (int retVal___, struct item_data *id); +typedef int (*HPMHOOK_pre_itemdb_validate_entry) (struct item_data **entry, int *n, const char **source); +typedef int (*HPMHOOK_post_itemdb_validate_entry) (int retVal___, struct item_data *entry, int n, const char *source); +typedef void (*HPMHOOK_pre_itemdb_readdb_additional_fields) (int *itemid, struct config_setting_t **it, int *n, const char **source); +typedef void (*HPMHOOK_post_itemdb_readdb_additional_fields) (int itemid, struct config_setting_t *it, int n, const char *source); +typedef void (*HPMHOOK_pre_itemdb_readdb_job_sub) (struct item_data **id, struct config_setting_t **t); +typedef void (*HPMHOOK_post_itemdb_readdb_job_sub) (struct item_data *id, struct config_setting_t *t); +typedef int (*HPMHOOK_pre_itemdb_readdb_libconfig_sub) (struct config_setting_t **it, int *n, const char **source); +typedef int (*HPMHOOK_post_itemdb_readdb_libconfig_sub) (int retVal___, struct config_setting_t *it, int n, const char *source); +typedef int (*HPMHOOK_pre_itemdb_readdb_libconfig) (const char **filename); +typedef int (*HPMHOOK_post_itemdb_readdb_libconfig) (int retVal___, const char *filename); +typedef uint64 (*HPMHOOK_pre_itemdb_unique_id) (struct map_session_data **sd); +typedef uint64 (*HPMHOOK_post_itemdb_unique_id) (uint64 retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_itemdb_read) (bool *minimal); +typedef void (*HPMHOOK_post_itemdb_read) (bool minimal); +typedef void (*HPMHOOK_pre_itemdb_destroy_item_data) (struct item_data **self, int *free_self); +typedef void (*HPMHOOK_post_itemdb_destroy_item_data) (struct item_data *self, int free_self); +typedef int (*HPMHOOK_pre_itemdb_final_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_itemdb_final_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_itemdb_clear) (bool *total); +typedef void (*HPMHOOK_post_itemdb_clear) (bool total); +typedef struct item_combo* (*HPMHOOK_pre_itemdb_id2combo) (unsigned short *id); +typedef struct item_combo* (*HPMHOOK_post_itemdb_id2combo) (struct item_combo* retVal___, unsigned short id); +typedef bool (*HPMHOOK_pre_itemdb_is_item_usable) (struct item_data **item); +typedef bool (*HPMHOOK_post_itemdb_is_item_usable) (bool retVal___, struct item_data *item); +typedef bool (*HPMHOOK_pre_itemdb_lookup_const) (const struct config_setting_t **it, const char **name, int **value); +typedef bool (*HPMHOOK_post_itemdb_lookup_const) (bool retVal___, const struct config_setting_t *it, const char *name, int *value); +#endif // MAP_ITEMDB_H +#ifdef LOGIN_LCLIF_H /* lclif */ +typedef void (*HPMHOOK_pre_lclif_init) (void); +typedef void (*HPMHOOK_post_lclif_init) (void); +typedef void (*HPMHOOK_pre_lclif_final) (void); +typedef void (*HPMHOOK_post_lclif_final) (void); +typedef void (*HPMHOOK_pre_lclif_connection_error) (int *fd, uint8 *error); +typedef void (*HPMHOOK_post_lclif_connection_error) (int fd, uint8 error); +typedef bool (*HPMHOOK_pre_lclif_server_list) (struct login_session_data **sd); +typedef bool (*HPMHOOK_post_lclif_server_list) (bool retVal___, struct login_session_data *sd); +typedef void (*HPMHOOK_pre_lclif_auth_failed) (int *fd, time_t *ban, uint32 *error); +typedef void (*HPMHOOK_post_lclif_auth_failed) (int fd, time_t ban, uint32 error); +typedef void (*HPMHOOK_pre_lclif_login_error) (int *fd, uint8 *error); +typedef void (*HPMHOOK_post_lclif_login_error) (int fd, uint8 error); +typedef void (*HPMHOOK_pre_lclif_coding_key) (int *fd, struct login_session_data **sd); +typedef void (*HPMHOOK_post_lclif_coding_key) (int fd, struct login_session_data *sd); +typedef const struct login_packet_db* (*HPMHOOK_pre_lclif_packet) (int16 *packet_id); +typedef const struct login_packet_db* (*HPMHOOK_post_lclif_packet) (const struct login_packet_db* retVal___, int16 packet_id); +typedef enum parsefunc_rcode (*HPMHOOK_pre_lclif_parse_packet) (const struct login_packet_db **lpd, int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_lclif_parse_packet) (enum parsefunc_rcode retVal___, const struct login_packet_db *lpd, int fd, struct login_session_data *sd); +typedef int (*HPMHOOK_pre_lclif_parse) (int *fd); +typedef int (*HPMHOOK_post_lclif_parse) (int retVal___, int fd); +#endif // LOGIN_LCLIF_H +#ifdef LOGIN_LCLIF_P_H /* PRIV__lclif */ +typedef void (*HPMHOOK_pre_PRIV__lclif_packetdb_loaddb) (void); +typedef void (*HPMHOOK_post_PRIV__lclif_packetdb_loaddb) (void); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_sub) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_sub) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_EXE_HASHCHECK) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_EXE_HASHCHECK) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN2) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN2) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN3) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN3) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN4) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN4) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN_PCBANG) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN_PCBANG) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_LOGIN_HAN) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_LOGIN_HAN) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_SSO_LOGIN_REQ) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_SSO_LOGIN_REQ) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_REQ_HASH) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_REQ_HASH) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +typedef enum parsefunc_rcode (*HPMHOOK_pre_PRIV__lclif_parse_CA_CHARSERVERCONNECT) (int *fd, struct login_session_data **sd); +typedef enum parsefunc_rcode (*HPMHOOK_post_PRIV__lclif_parse_CA_CHARSERVERCONNECT) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); +#endif // LOGIN_LCLIF_P_H +#ifdef COMMON_CONF_H /* libconfig */ +typedef int (*HPMHOOK_pre_libconfig_read) (struct config_t **config, FILE **stream); +typedef int (*HPMHOOK_post_libconfig_read) (int retVal___, struct config_t *config, FILE *stream); +typedef void (*HPMHOOK_pre_libconfig_write) (const struct config_t **config, FILE **stream); +typedef void (*HPMHOOK_post_libconfig_write) (const struct config_t *config, FILE *stream); +typedef void (*HPMHOOK_pre_libconfig_set_options) (struct config_t **config, int *options); +typedef void (*HPMHOOK_post_libconfig_set_options) (struct config_t *config, int options); +typedef int (*HPMHOOK_pre_libconfig_get_options) (const struct config_t **config); +typedef int (*HPMHOOK_post_libconfig_get_options) (int retVal___, const struct config_t *config); +typedef int (*HPMHOOK_pre_libconfig_read_string) (struct config_t **config, const char **str); +typedef int (*HPMHOOK_post_libconfig_read_string) (int retVal___, struct config_t *config, const char *str); +typedef int (*HPMHOOK_pre_libconfig_read_file_src) (struct config_t **config, const char **filename); +typedef int (*HPMHOOK_post_libconfig_read_file_src) (int retVal___, struct config_t *config, const char *filename); +typedef int (*HPMHOOK_pre_libconfig_write_file) (struct config_t **config, const char **filename); +typedef int (*HPMHOOK_post_libconfig_write_file) (int retVal___, struct config_t *config, const char *filename); +typedef void (*HPMHOOK_pre_libconfig_set_destructor) (struct config_t **config, void ( **destructor ) (void *)); +typedef void (*HPMHOOK_post_libconfig_set_destructor) (struct config_t *config, void ( *destructor ) (void *)); +typedef void (*HPMHOOK_pre_libconfig_set_include_dir) (struct config_t **config, const char **include_dir); +typedef void (*HPMHOOK_post_libconfig_set_include_dir) (struct config_t *config, const char *include_dir); +typedef void (*HPMHOOK_pre_libconfig_init) (struct config_t **config); +typedef void (*HPMHOOK_post_libconfig_init) (struct config_t *config); +typedef void (*HPMHOOK_pre_libconfig_destroy) (struct config_t **config); +typedef void (*HPMHOOK_post_libconfig_destroy) (struct config_t *config); +typedef int (*HPMHOOK_pre_libconfig_setting_get_int) (const struct config_setting_t **setting); +typedef int (*HPMHOOK_post_libconfig_setting_get_int) (int retVal___, const struct config_setting_t *setting); +typedef long long (*HPMHOOK_pre_libconfig_setting_get_int64) (const struct config_setting_t **setting); +typedef long long (*HPMHOOK_post_libconfig_setting_get_int64) (long long retVal___, const struct config_setting_t *setting); +typedef double (*HPMHOOK_pre_libconfig_setting_get_float) (const struct config_setting_t **setting); +typedef double (*HPMHOOK_post_libconfig_setting_get_float) (double retVal___, const struct config_setting_t *setting); +typedef int (*HPMHOOK_pre_libconfig_setting_get_bool) (const struct config_setting_t **setting); +typedef int (*HPMHOOK_post_libconfig_setting_get_bool) (int retVal___, const struct config_setting_t *setting); +typedef const char* (*HPMHOOK_pre_libconfig_setting_get_string) (const struct config_setting_t **setting); +typedef const char* (*HPMHOOK_post_libconfig_setting_get_string) (const char* retVal___, const struct config_setting_t *setting); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_lookup) (struct config_setting_t **setting, const char **name); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_lookup) (struct config_setting_t* retVal___, struct config_setting_t *setting, const char *name); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_int) (const struct config_setting_t **setting, const char **name, int **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_int) (int retVal___, const struct config_setting_t *setting, const char *name, int *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_int64) (const struct config_setting_t **setting, const char **name, long long **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_int64) (int retVal___, const struct config_setting_t *setting, const char *name, long long *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_float) (const struct config_setting_t **setting, const char **name, double **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_float) (int retVal___, const struct config_setting_t *setting, const char *name, double *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_bool) (const struct config_setting_t **setting, const char **name, int **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_bool) (int retVal___, const struct config_setting_t *setting, const char *name, int *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_string) (const struct config_setting_t **setting, const char **name, const char ***value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_string) (int retVal___, const struct config_setting_t *setting, const char *name, const char **value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_int) (struct config_setting_t **setting, int *value); +typedef int (*HPMHOOK_post_libconfig_setting_set_int) (int retVal___, struct config_setting_t *setting, int value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_int64) (struct config_setting_t **setting, long long *value); +typedef int (*HPMHOOK_post_libconfig_setting_set_int64) (int retVal___, struct config_setting_t *setting, long long value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_float) (struct config_setting_t **setting, double *value); +typedef int (*HPMHOOK_post_libconfig_setting_set_float) (int retVal___, struct config_setting_t *setting, double value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_bool) (struct config_setting_t **setting, int *value); +typedef int (*HPMHOOK_post_libconfig_setting_set_bool) (int retVal___, struct config_setting_t *setting, int value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_string) (struct config_setting_t **setting, const char **value); +typedef int (*HPMHOOK_post_libconfig_setting_set_string) (int retVal___, struct config_setting_t *setting, const char *value); +typedef int (*HPMHOOK_pre_libconfig_setting_set_format) (struct config_setting_t **setting, short *format); +typedef int (*HPMHOOK_post_libconfig_setting_set_format) (int retVal___, struct config_setting_t *setting, short format); +typedef short (*HPMHOOK_pre_libconfig_setting_get_format) (const struct config_setting_t **setting); +typedef short (*HPMHOOK_post_libconfig_setting_get_format) (short retVal___, const struct config_setting_t *setting); +typedef int (*HPMHOOK_pre_libconfig_setting_get_int_elem) (const struct config_setting_t **setting, int *idx); +typedef int (*HPMHOOK_post_libconfig_setting_get_int_elem) (int retVal___, const struct config_setting_t *setting, int idx); +typedef long long (*HPMHOOK_pre_libconfig_setting_get_int64_elem) (const struct config_setting_t **setting, int *idx); +typedef long long (*HPMHOOK_post_libconfig_setting_get_int64_elem) (long long retVal___, const struct config_setting_t *setting, int idx); +typedef double (*HPMHOOK_pre_libconfig_setting_get_float_elem) (const struct config_setting_t **setting, int *idx); +typedef double (*HPMHOOK_post_libconfig_setting_get_float_elem) (double retVal___, const struct config_setting_t *setting, int idx); +typedef int (*HPMHOOK_pre_libconfig_setting_get_bool_elem) (const struct config_setting_t **setting, int *idx); +typedef int (*HPMHOOK_post_libconfig_setting_get_bool_elem) (int retVal___, const struct config_setting_t *setting, int idx); +typedef const char* (*HPMHOOK_pre_libconfig_setting_get_string_elem) (const struct config_setting_t **setting, int *idx); +typedef const char* (*HPMHOOK_post_libconfig_setting_get_string_elem) (const char* retVal___, const struct config_setting_t *setting, int idx); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_set_int_elem) (struct config_setting_t **setting, int *idx, int *value); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_set_int_elem) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_set_int64_elem) (struct config_setting_t **setting, int *idx, long long *value); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_set_int64_elem) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, long long value); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_set_float_elem) (struct config_setting_t **setting, int *idx, double *value); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_set_float_elem) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, double value); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_set_bool_elem) (struct config_setting_t **setting, int *idx, int *value); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_set_bool_elem) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_set_string_elem) (struct config_setting_t **setting, int *idx, const char **value); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_set_string_elem) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, const char *value); +typedef int (*HPMHOOK_pre_libconfig_setting_index) (const struct config_setting_t **setting); +typedef int (*HPMHOOK_post_libconfig_setting_index) (int retVal___, const struct config_setting_t *setting); +typedef int (*HPMHOOK_pre_libconfig_setting_length) (const struct config_setting_t **setting); +typedef int (*HPMHOOK_post_libconfig_setting_length) (int retVal___, const struct config_setting_t *setting); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_get_elem) (const struct config_setting_t **setting, unsigned int *idx); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_get_elem) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int idx); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_get_member) (const struct config_setting_t **setting, const char **name); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_get_member) (struct config_setting_t* retVal___, const struct config_setting_t *setting, const char *name); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_setting_add) (struct config_setting_t **parent, const char **name, int *type); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_setting_add) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int type); +typedef int (*HPMHOOK_pre_libconfig_setting_remove) (struct config_setting_t **parent, const char **name); +typedef int (*HPMHOOK_post_libconfig_setting_remove) (int retVal___, struct config_setting_t *parent, const char *name); +typedef int (*HPMHOOK_pre_libconfig_setting_remove_elem) (struct config_setting_t **parent, unsigned int *idx); +typedef int (*HPMHOOK_post_libconfig_setting_remove_elem) (int retVal___, struct config_setting_t *parent, unsigned int idx); +typedef void (*HPMHOOK_pre_libconfig_setting_set_hook) (struct config_setting_t **setting, void **hook); +typedef void (*HPMHOOK_post_libconfig_setting_set_hook) (struct config_setting_t *setting, void *hook); +typedef struct config_setting_t* (*HPMHOOK_pre_libconfig_lookup) (const struct config_t **config, const char **filepath); +typedef struct config_setting_t* (*HPMHOOK_post_libconfig_lookup) (struct config_setting_t* retVal___, const struct config_t *config, const char *filepath); +typedef int (*HPMHOOK_pre_libconfig_lookup_int) (const struct config_t **config, const char **filepath, int **value); +typedef int (*HPMHOOK_post_libconfig_lookup_int) (int retVal___, const struct config_t *config, const char *filepath, int *value); +typedef int (*HPMHOOK_pre_libconfig_lookup_int64) (const struct config_t **config, const char **filepath, long long **value); +typedef int (*HPMHOOK_post_libconfig_lookup_int64) (int retVal___, const struct config_t *config, const char *filepath, long long *value); +typedef int (*HPMHOOK_pre_libconfig_lookup_float) (const struct config_t **config, const char **filepath, double **value); +typedef int (*HPMHOOK_post_libconfig_lookup_float) (int retVal___, const struct config_t *config, const char *filepath, double *value); +typedef int (*HPMHOOK_pre_libconfig_lookup_bool) (const struct config_t **config, const char **filepath, int **value); +typedef int (*HPMHOOK_post_libconfig_lookup_bool) (int retVal___, const struct config_t *config, const char *filepath, int *value); +typedef int (*HPMHOOK_pre_libconfig_lookup_string) (const struct config_t **config, const char **filepath, const char ***value); +typedef int (*HPMHOOK_post_libconfig_lookup_string) (int retVal___, const struct config_t *config, const char *filepath, const char **value); +typedef int (*HPMHOOK_pre_libconfig_load_file) (struct config_t **config, const char **config_filename); +typedef int (*HPMHOOK_post_libconfig_load_file) (int retVal___, struct config_t *config, const char *config_filename); +typedef void (*HPMHOOK_pre_libconfig_setting_copy_simple) (struct config_setting_t **parent, const struct config_setting_t **src); +typedef void (*HPMHOOK_post_libconfig_setting_copy_simple) (struct config_setting_t *parent, const struct config_setting_t *src); +typedef void (*HPMHOOK_pre_libconfig_setting_copy_elem) (struct config_setting_t **parent, const struct config_setting_t **src); +typedef void (*HPMHOOK_post_libconfig_setting_copy_elem) (struct config_setting_t *parent, const struct config_setting_t *src); +typedef void (*HPMHOOK_pre_libconfig_setting_copy_aggregate) (struct config_setting_t **parent, const struct config_setting_t **src); +typedef void (*HPMHOOK_post_libconfig_setting_copy_aggregate) (struct config_setting_t *parent, const struct config_setting_t *src); +typedef int (*HPMHOOK_pre_libconfig_setting_copy) (struct config_setting_t **parent, const struct config_setting_t **src); +typedef int (*HPMHOOK_post_libconfig_setting_copy) (int retVal___, struct config_setting_t *parent, const struct config_setting_t *src); +typedef bool (*HPMHOOK_pre_libconfig_setting_get_bool_real) (const struct config_setting_t **setting); +typedef bool (*HPMHOOK_post_libconfig_setting_get_bool_real) (bool retVal___, const struct config_setting_t *setting); +typedef uint32 (*HPMHOOK_pre_libconfig_setting_get_uint32) (const struct config_setting_t **setting); +typedef uint32 (*HPMHOOK_post_libconfig_setting_get_uint32) (uint32 retVal___, const struct config_setting_t *setting); +typedef uint16 (*HPMHOOK_pre_libconfig_setting_get_uint16) (const struct config_setting_t **setting); +typedef uint16 (*HPMHOOK_post_libconfig_setting_get_uint16) (uint16 retVal___, const struct config_setting_t *setting); +typedef int16 (*HPMHOOK_pre_libconfig_setting_get_int16) (const struct config_setting_t **setting); +typedef int16 (*HPMHOOK_post_libconfig_setting_get_int16) (int16 retVal___, const struct config_setting_t *setting); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_bool_real) (const struct config_setting_t **setting, const char **name, bool **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_bool_real) (int retVal___, const struct config_setting_t *setting, const char *name, bool *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_uint32) (const struct config_setting_t **setting, const char **name, uint32 **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_uint32) (int retVal___, const struct config_setting_t *setting, const char *name, uint32 *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_uint16) (const struct config_setting_t **setting, const char **name, uint16 **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_uint16) (int retVal___, const struct config_setting_t *setting, const char *name, uint16 *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_int16) (const struct config_setting_t **setting, const char **name, int16 **value); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_int16) (int retVal___, const struct config_setting_t *setting, const char *name, int16 *value); +typedef int (*HPMHOOK_pre_libconfig_setting_lookup_mutable_string) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size); +typedef int (*HPMHOOK_post_libconfig_setting_lookup_mutable_string) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size); +typedef int (*HPMHOOK_pre_libconfig_lookup_mutable_string) (const struct config_t **config, const char **name, char **out, size_t *out_size); +typedef int (*HPMHOOK_post_libconfig_lookup_mutable_string) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size); +#endif // COMMON_CONF_H +#ifdef MAP_LOG_H /* logs */ +typedef void (*HPMHOOK_pre_logs_pick_pc) (struct map_session_data **sd, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); +typedef void (*HPMHOOK_post_logs_pick_pc) (struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); +typedef void (*HPMHOOK_pre_logs_pick_mob) (struct mob_data **md, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); +typedef void (*HPMHOOK_post_logs_pick_mob) (struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); +typedef void (*HPMHOOK_pre_logs_zeny) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount); +typedef void (*HPMHOOK_post_logs_zeny) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount); +typedef void (*HPMHOOK_pre_logs_npc) (struct map_session_data **sd, const char **message); +typedef void (*HPMHOOK_post_logs_npc) (struct map_session_data *sd, const char *message); +typedef void (*HPMHOOK_pre_logs_chat) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message); +typedef void (*HPMHOOK_post_logs_chat) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message); +typedef void (*HPMHOOK_pre_logs_atcommand) (struct map_session_data **sd, const char **message); +typedef void (*HPMHOOK_post_logs_atcommand) (struct map_session_data *sd, const char *message); +typedef void (*HPMHOOK_pre_logs_branch) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_logs_branch) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_logs_mvpdrop) (struct map_session_data **sd, int *monster_id, int **log_mvp); +typedef void (*HPMHOOK_post_logs_mvpdrop) (struct map_session_data *sd, int monster_id, int *log_mvp); +typedef void (*HPMHOOK_pre_logs_pick_sub) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); +typedef void (*HPMHOOK_post_logs_pick_sub) (int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); +typedef void (*HPMHOOK_pre_logs_zeny_sub) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount); +typedef void (*HPMHOOK_post_logs_zeny_sub) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount); +typedef void (*HPMHOOK_pre_logs_npc_sub) (struct map_session_data **sd, const char **message); +typedef void (*HPMHOOK_post_logs_npc_sub) (struct map_session_data *sd, const char *message); +typedef void (*HPMHOOK_pre_logs_chat_sub) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message); +typedef void (*HPMHOOK_post_logs_chat_sub) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message); +typedef void (*HPMHOOK_pre_logs_atcommand_sub) (struct map_session_data **sd, const char **message); +typedef void (*HPMHOOK_post_logs_atcommand_sub) (struct map_session_data *sd, const char *message); +typedef void (*HPMHOOK_pre_logs_branch_sub) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_logs_branch_sub) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_logs_mvpdrop_sub) (struct map_session_data **sd, int *monster_id, int **log_mvp); +typedef void (*HPMHOOK_post_logs_mvpdrop_sub) (struct map_session_data *sd, int monster_id, int *log_mvp); +typedef int (*HPMHOOK_pre_logs_config_read) (const char **cfgName); +typedef int (*HPMHOOK_post_logs_config_read) (int retVal___, const char *cfgName); +typedef void (*HPMHOOK_pre_logs_config_done) (void); +typedef void (*HPMHOOK_post_logs_config_done) (void); +typedef void (*HPMHOOK_pre_logs_sql_init) (void); +typedef void (*HPMHOOK_post_logs_sql_init) (void); +typedef void (*HPMHOOK_pre_logs_sql_final) (void); +typedef void (*HPMHOOK_post_logs_sql_final) (void); +typedef char (*HPMHOOK_pre_logs_picktype2char) (e_log_pick_type *type); +typedef char (*HPMHOOK_post_logs_picktype2char) (char retVal___, e_log_pick_type type); +typedef char (*HPMHOOK_pre_logs_chattype2char) (e_log_chat_type *type); +typedef char (*HPMHOOK_post_logs_chattype2char) (char retVal___, e_log_chat_type type); +typedef bool (*HPMHOOK_pre_logs_should_log_item) (int *nameid, int *amount, int *refine, struct item_data **id); +typedef bool (*HPMHOOK_post_logs_should_log_item) (bool retVal___, int nameid, int amount, int refine, struct item_data *id); +#endif // MAP_LOG_H +#ifdef LOGIN_LOGIN_H /* login */ +typedef int (*HPMHOOK_pre_login_mmo_auth) (struct login_session_data **sd, bool *isServer); +typedef int (*HPMHOOK_post_login_mmo_auth) (int retVal___, struct login_session_data *sd, bool isServer); +typedef int (*HPMHOOK_pre_login_mmo_auth_new) (const char **userid, const char **pass, const char *sex, const char **last_ip); +typedef int (*HPMHOOK_post_login_mmo_auth_new) (int retVal___, const char *userid, const char *pass, const char sex, const char *last_ip); +typedef int (*HPMHOOK_pre_login_waiting_disconnect_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_login_waiting_disconnect_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef struct DBData (*HPMHOOK_pre_login_create_online_user) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_login_create_online_user) (struct DBData retVal___, union DBKey key, va_list args); +typedef struct online_login_data* (*HPMHOOK_pre_login_add_online_user) (int *char_server, int *account_id); +typedef struct online_login_data* (*HPMHOOK_post_login_add_online_user) (struct online_login_data* retVal___, int char_server, int account_id); +typedef void (*HPMHOOK_pre_login_remove_online_user) (int *account_id); +typedef void (*HPMHOOK_post_login_remove_online_user) (int account_id); +typedef int (*HPMHOOK_pre_login_online_db_setoffline) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_login_online_db_setoffline) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_login_online_data_cleanup_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_login_online_data_cleanup_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_login_online_data_cleanup) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_login_online_data_cleanup) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_login_sync_ip_addresses) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_login_sync_ip_addresses) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef bool (*HPMHOOK_pre_login_check_encrypted) (const char **str1, const char **str2, const char **passwd); +typedef bool (*HPMHOOK_post_login_check_encrypted) (bool retVal___, const char *str1, const char *str2, const char *passwd); +typedef bool (*HPMHOOK_pre_login_check_password) (const char **md5key, int *passwdenc, const char **passwd, const char **refpass); +typedef bool (*HPMHOOK_post_login_check_password) (bool retVal___, const char *md5key, int passwdenc, const char *passwd, const char *refpass); +typedef uint32 (*HPMHOOK_pre_login_lan_subnet_check) (uint32 *ip); +typedef uint32 (*HPMHOOK_post_login_lan_subnet_check) (uint32 retVal___, uint32 ip); +typedef void (*HPMHOOK_pre_login_fromchar_accinfo) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account **acc); +typedef void (*HPMHOOK_post_login_fromchar_accinfo) (int fd, int account_id, int u_fd, int u_aid, int u_group, int map_fd, struct mmo_account *acc); +typedef void (*HPMHOOK_pre_login_fromchar_account) (int *fd, int *account_id, struct mmo_account **acc); +typedef void (*HPMHOOK_post_login_fromchar_account) (int fd, int account_id, struct mmo_account *acc); +typedef void (*HPMHOOK_pre_login_fromchar_account_update_other) (int *account_id, unsigned int *state); +typedef void (*HPMHOOK_post_login_fromchar_account_update_other) (int account_id, unsigned int state); +typedef void (*HPMHOOK_pre_login_fromchar_auth_ack) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node **node); +typedef void (*HPMHOOK_post_login_fromchar_auth_ack) (int fd, int account_id, uint32 login_id1, uint32 login_id2, uint8 sex, int request_id, struct login_auth_node *node); +typedef void (*HPMHOOK_pre_login_fromchar_ban) (int *account_id, time_t *timestamp); +typedef void (*HPMHOOK_post_login_fromchar_ban) (int account_id, time_t timestamp); +typedef void (*HPMHOOK_pre_login_fromchar_change_sex_other) (int *account_id, char *sex); +typedef void (*HPMHOOK_post_login_fromchar_change_sex_other) (int account_id, char sex); +typedef void (*HPMHOOK_pre_login_fromchar_pong) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_pong) (int fd); +typedef void (*HPMHOOK_pre_login_fromchar_parse_auth) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_auth) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_update_users) (int *fd, int *id); +typedef void (*HPMHOOK_post_login_fromchar_parse_update_users) (int fd, int id); +typedef void (*HPMHOOK_pre_login_fromchar_parse_request_change_email) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_request_change_email) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_account_data) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_account_data) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_ping) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_parse_ping) (int fd); +typedef void (*HPMHOOK_pre_login_fromchar_parse_change_email) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_change_email) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_account_update) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_account_update) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_ban) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_ban) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_change_sex) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_change_sex) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_account_reg2) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_account_reg2) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_unban) (int *fd, int *id, const char **ip); +typedef void (*HPMHOOK_post_login_fromchar_parse_unban) (int fd, int id, const char *ip); +typedef void (*HPMHOOK_pre_login_fromchar_parse_account_online) (int *fd, int *id); +typedef void (*HPMHOOK_post_login_fromchar_parse_account_online) (int fd, int id); +typedef void (*HPMHOOK_pre_login_fromchar_parse_account_offline) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_parse_account_offline) (int fd); +typedef void (*HPMHOOK_pre_login_fromchar_parse_online_accounts) (int *fd, int *id); +typedef void (*HPMHOOK_post_login_fromchar_parse_online_accounts) (int fd, int id); +typedef void (*HPMHOOK_pre_login_fromchar_parse_request_account_reg2) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_parse_request_account_reg2) (int fd); +typedef void (*HPMHOOK_pre_login_fromchar_parse_update_wan_ip) (int *fd, int *id); +typedef void (*HPMHOOK_post_login_fromchar_parse_update_wan_ip) (int fd, int id); +typedef void (*HPMHOOK_pre_login_fromchar_parse_all_offline) (int *fd, int *id); +typedef void (*HPMHOOK_post_login_fromchar_parse_all_offline) (int fd, int id); +typedef void (*HPMHOOK_pre_login_fromchar_parse_change_pincode) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_parse_change_pincode) (int fd); +typedef bool (*HPMHOOK_pre_login_fromchar_parse_wrong_pincode) (int *fd); +typedef bool (*HPMHOOK_post_login_fromchar_parse_wrong_pincode) (bool retVal___, int fd); +typedef void (*HPMHOOK_pre_login_fromchar_parse_accinfo) (int *fd); +typedef void (*HPMHOOK_post_login_fromchar_parse_accinfo) (int fd); +typedef int (*HPMHOOK_pre_login_parse_fromchar) (int *fd); +typedef int (*HPMHOOK_post_login_parse_fromchar) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_login_kick) (struct login_session_data **sd); +typedef void (*HPMHOOK_post_login_kick) (struct login_session_data *sd); +typedef void (*HPMHOOK_pre_login_auth_ok) (struct login_session_data **sd); +typedef void (*HPMHOOK_post_login_auth_ok) (struct login_session_data *sd); +typedef void (*HPMHOOK_pre_login_auth_failed) (struct login_session_data **sd, int *result); +typedef void (*HPMHOOK_post_login_auth_failed) (struct login_session_data *sd, int result); +typedef bool (*HPMHOOK_pre_login_client_login) (int *fd, struct login_session_data **sd); +typedef bool (*HPMHOOK_post_login_client_login) (bool retVal___, int fd, struct login_session_data *sd); +typedef void (*HPMHOOK_pre_login_char_server_connection_status) (int *fd, struct login_session_data **sd, uint8 *status); +typedef void (*HPMHOOK_post_login_char_server_connection_status) (int fd, struct login_session_data *sd, uint8 status); +typedef void (*HPMHOOK_pre_login_parse_request_connection) (int *fd, struct login_session_data **sd, const char **ip, uint32 *ipl); +typedef void (*HPMHOOK_post_login_parse_request_connection) (int fd, struct login_session_data *sd, const char *ip, uint32 ipl); +typedef void (*HPMHOOK_pre_login_config_set_defaults) (void); +typedef void (*HPMHOOK_post_login_config_set_defaults) (void); +typedef int (*HPMHOOK_pre_login_config_read) (const char **cfgName); +typedef int (*HPMHOOK_post_login_config_read) (int retVal___, const char *cfgName); +#endif // LOGIN_LOGIN_H +#ifdef CHAR_LOGINIF_H /* loginif */ +typedef void (*HPMHOOK_pre_loginif_init) (void); +typedef void (*HPMHOOK_post_loginif_init) (void); +typedef void (*HPMHOOK_pre_loginif_final) (void); +typedef void (*HPMHOOK_post_loginif_final) (void); +typedef void (*HPMHOOK_pre_loginif_reset) (void); +typedef void (*HPMHOOK_post_loginif_reset) (void); +typedef void (*HPMHOOK_pre_loginif_check_shutdown) (void); +typedef void (*HPMHOOK_post_loginif_check_shutdown) (void); +typedef void (*HPMHOOK_pre_loginif_on_disconnect) (void); +typedef void (*HPMHOOK_post_loginif_on_disconnect) (void); +typedef void (*HPMHOOK_pre_loginif_on_ready) (void); +typedef void (*HPMHOOK_post_loginif_on_ready) (void); +typedef void (*HPMHOOK_pre_loginif_block_account) (int *account_id, int *flag); +typedef void (*HPMHOOK_post_loginif_block_account) (int account_id, int flag); +typedef void (*HPMHOOK_pre_loginif_ban_account) (int *account_id, short *year, short *month, short *day, short *hour, short *minute, short *second); +typedef void (*HPMHOOK_post_loginif_ban_account) (int account_id, short year, short month, short day, short hour, short minute, short second); +typedef void (*HPMHOOK_pre_loginif_unban_account) (int *account_id); +typedef void (*HPMHOOK_post_loginif_unban_account) (int account_id); +typedef void (*HPMHOOK_pre_loginif_changesex) (int *account_id); +typedef void (*HPMHOOK_post_loginif_changesex) (int account_id); +typedef void (*HPMHOOK_pre_loginif_auth) (int *fd, struct char_session_data **sd, uint32 *ipl); +typedef void (*HPMHOOK_post_loginif_auth) (int fd, struct char_session_data *sd, uint32 ipl); +typedef void (*HPMHOOK_pre_loginif_send_users_count) (int *users); +typedef void (*HPMHOOK_post_loginif_send_users_count) (int users); +typedef void (*HPMHOOK_pre_loginif_connect_to_server) (void); +typedef void (*HPMHOOK_post_loginif_connect_to_server) (void); +#endif // CHAR_LOGINIF_H +#ifdef MAP_MAIL_H /* mail */ +typedef void (*HPMHOOK_pre_mail_clear) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_mail_clear) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_mail_removeitem) (struct map_session_data **sd, short *flag); +typedef int (*HPMHOOK_post_mail_removeitem) (int retVal___, struct map_session_data *sd, short flag); +typedef int (*HPMHOOK_pre_mail_removezeny) (struct map_session_data **sd, short *flag); +typedef int (*HPMHOOK_post_mail_removezeny) (int retVal___, struct map_session_data *sd, short flag); +typedef unsigned char (*HPMHOOK_pre_mail_setitem) (struct map_session_data **sd, int *idx, int *amount); +typedef unsigned char (*HPMHOOK_post_mail_setitem) (unsigned char retVal___, struct map_session_data *sd, int idx, int amount); +typedef bool (*HPMHOOK_pre_mail_setattachment) (struct map_session_data **sd, struct mail_message **msg); +typedef bool (*HPMHOOK_post_mail_setattachment) (bool retVal___, struct map_session_data *sd, struct mail_message *msg); +typedef void (*HPMHOOK_pre_mail_getattachment) (struct map_session_data **sd, int *zeny, struct item **item); +typedef void (*HPMHOOK_post_mail_getattachment) (struct map_session_data *sd, int zeny, struct item *item); +typedef int (*HPMHOOK_pre_mail_openmail) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_mail_openmail) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_mail_deliveryfail) (struct map_session_data **sd, struct mail_message **msg); +typedef void (*HPMHOOK_post_mail_deliveryfail) (struct map_session_data *sd, struct mail_message *msg); +typedef bool (*HPMHOOK_pre_mail_invalid_operation) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_mail_invalid_operation) (bool retVal___, struct map_session_data *sd); +#endif // MAP_MAIL_H +#ifdef COMMON_MEMMGR_H /* iMalloc */ +typedef void (*HPMHOOK_pre_iMalloc_init) (void); +typedef void (*HPMHOOK_post_iMalloc_init) (void); +typedef void (*HPMHOOK_pre_iMalloc_final) (void); +typedef void (*HPMHOOK_post_iMalloc_final) (void); +typedef void* (*HPMHOOK_pre_iMalloc_malloc) (size_t *size, const char **file, int *line, const char **func); +typedef void* (*HPMHOOK_post_iMalloc_malloc) (void* retVal___, size_t size, const char *file, int line, const char *func); +typedef void* (*HPMHOOK_pre_iMalloc_calloc) (size_t *num, size_t *size, const char **file, int *line, const char **func); +typedef void* (*HPMHOOK_post_iMalloc_calloc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func); +typedef void* (*HPMHOOK_pre_iMalloc_realloc) (void **p, size_t *size, const char **file, int *line, const char **func); +typedef void* (*HPMHOOK_post_iMalloc_realloc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); +typedef void* (*HPMHOOK_pre_iMalloc_reallocz) (void **p, size_t *size, const char **file, int *line, const char **func); +typedef void* (*HPMHOOK_post_iMalloc_reallocz) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); +typedef char* (*HPMHOOK_pre_iMalloc_astrdup) (const char **p, const char **file, int *line, const char **func); +typedef char* (*HPMHOOK_post_iMalloc_astrdup) (char* retVal___, const char *p, const char *file, int line, const char *func); +typedef char* (*HPMHOOK_pre_iMalloc_astrndup) (const char **p, size_t *size, const char **file, int *line, const char **func); +typedef char* (*HPMHOOK_post_iMalloc_astrndup) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func); +typedef void (*HPMHOOK_pre_iMalloc_free) (void **p, const char **file, int *line, const char **func); +typedef void (*HPMHOOK_post_iMalloc_free) (void *p, const char *file, int line, const char *func); +typedef void (*HPMHOOK_pre_iMalloc_memory_check) (void); +typedef void (*HPMHOOK_post_iMalloc_memory_check) (void); +typedef bool (*HPMHOOK_pre_iMalloc_verify_ptr) (void **ptr); +typedef bool (*HPMHOOK_post_iMalloc_verify_ptr) (bool retVal___, void *ptr); +typedef size_t (*HPMHOOK_pre_iMalloc_usage) (void); +typedef size_t (*HPMHOOK_post_iMalloc_usage) (size_t retVal___); +typedef void (*HPMHOOK_pre_iMalloc_post_shutdown) (void); +typedef void (*HPMHOOK_post_iMalloc_post_shutdown) (void); +typedef void (*HPMHOOK_pre_iMalloc_init_messages) (void); +typedef void (*HPMHOOK_post_iMalloc_init_messages) (void); +#endif // COMMON_MEMMGR_H +#ifdef MAP_MAP_H /* map */ +typedef void (*HPMHOOK_pre_map_zone_init) (void); +typedef void (*HPMHOOK_post_map_zone_init) (void); +typedef void (*HPMHOOK_pre_map_zone_remove) (int *m); +typedef void (*HPMHOOK_post_map_zone_remove) (int m); +typedef void (*HPMHOOK_pre_map_zone_apply) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath); +typedef void (*HPMHOOK_post_map_zone_apply) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); +typedef void (*HPMHOOK_pre_map_zone_change) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath); +typedef void (*HPMHOOK_post_map_zone_change) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); +typedef void (*HPMHOOK_pre_map_zone_change2) (int *m, struct map_zone_data **zone); +typedef void (*HPMHOOK_post_map_zone_change2) (int m, struct map_zone_data *zone); +typedef int (*HPMHOOK_pre_map_getcell) (int16 *m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); +typedef int (*HPMHOOK_post_map_getcell) (int retVal___, int16 m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); +typedef void (*HPMHOOK_pre_map_setgatcell) (int16 *m, int16 *x, int16 *y, int *gat); +typedef void (*HPMHOOK_post_map_setgatcell) (int16 m, int16 x, int16 y, int gat); +typedef void (*HPMHOOK_pre_map_cellfromcache) (struct map_data **m); +typedef void (*HPMHOOK_post_map_cellfromcache) (struct map_data *m); +typedef void (*HPMHOOK_pre_map_setusers) (int *p1); +typedef void (*HPMHOOK_post_map_setusers) (int p1); +typedef int (*HPMHOOK_pre_map_getusers) (void); +typedef int (*HPMHOOK_post_map_getusers) (int retVal___); +typedef int (*HPMHOOK_pre_map_usercount) (void); +typedef int (*HPMHOOK_post_map_usercount) (int retVal___); +typedef int (*HPMHOOK_pre_map_freeblock) (struct block_list **bl); +typedef int (*HPMHOOK_post_map_freeblock) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_map_freeblock_lock) (void); +typedef int (*HPMHOOK_post_map_freeblock_lock) (int retVal___); +typedef int (*HPMHOOK_pre_map_freeblock_unlock) (void); +typedef int (*HPMHOOK_post_map_freeblock_unlock) (int retVal___); +typedef int (*HPMHOOK_pre_map_addblock) (struct block_list **bl); +typedef int (*HPMHOOK_post_map_addblock) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_map_delblock) (struct block_list **bl); +typedef int (*HPMHOOK_post_map_delblock) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_map_moveblock) (struct block_list **bl, int *x1, int *y1, int64 *tick); +typedef int (*HPMHOOK_post_map_moveblock) (int retVal___, struct block_list *bl, int x1, int y1, int64 tick); +typedef int (*HPMHOOK_pre_map_count_oncell) (int16 *m, int16 *x, int16 *y, int *type, int *flag); +typedef int (*HPMHOOK_post_map_count_oncell) (int retVal___, int16 m, int16 x, int16 y, int type, int flag); +typedef struct skill_unit* (*HPMHOOK_pre_map_find_skill_unit_oncell) (struct block_list **target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit **out_unit, int *flag); +typedef struct skill_unit* (*HPMHOOK_post_map_find_skill_unit_oncell) (struct skill_unit* retVal___, struct block_list *target, int16 x, int16 y, uint16 skill_id, struct skill_unit *out_unit, int flag); +typedef int (*HPMHOOK_pre_map_get_new_object_id) (void); +typedef int (*HPMHOOK_post_map_get_new_object_id) (int retVal___); +typedef int (*HPMHOOK_pre_map_search_freecell) (struct block_list **src, int16 *m, int16 **x, int16 **y, int16 *rx, int16 *ry, int *flag); +typedef int (*HPMHOOK_post_map_search_freecell) (int retVal___, struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag); +typedef bool (*HPMHOOK_pre_map_closest_freecell) (int16 *m, const struct block_list **bl, int16 **x, int16 **y, int *type, int *flag); +typedef bool (*HPMHOOK_post_map_closest_freecell) (bool retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int type, int flag); +typedef int (*HPMHOOK_pre_map_quit) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_map_quit) (int retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_map_addnpc) (int16 *m, struct npc_data **nd); +typedef bool (*HPMHOOK_post_map_addnpc) (bool retVal___, int16 m, struct npc_data *nd); +typedef int (*HPMHOOK_pre_map_clearflooritem_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_map_clearflooritem_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_map_removemobs_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_map_removemobs_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_map_clearflooritem) (struct block_list **bl); +typedef void (*HPMHOOK_post_map_clearflooritem) (struct block_list *bl); +typedef int (*HPMHOOK_pre_map_addflooritem) (const struct block_list **bl, struct item **item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags); +typedef int (*HPMHOOK_post_map_addflooritem) (int retVal___, const struct block_list *bl, struct item *item_data, int amount, int16 m, int16 x, int16 y, int first_charid, int second_charid, int third_charid, int flags); +typedef void (*HPMHOOK_pre_map_addnickdb) (int *charid, const char **nick); +typedef void (*HPMHOOK_post_map_addnickdb) (int charid, const char *nick); +typedef void (*HPMHOOK_pre_map_delnickdb) (int *charid, const char **nick); +typedef void (*HPMHOOK_post_map_delnickdb) (int charid, const char *nick); +typedef void (*HPMHOOK_pre_map_reqnickdb) (struct map_session_data **sd, int *charid); +typedef void (*HPMHOOK_post_map_reqnickdb) (struct map_session_data *sd, int charid); +typedef const char* (*HPMHOOK_pre_map_charid2nick) (int *charid); +typedef const char* (*HPMHOOK_post_map_charid2nick) (const char* retVal___, int charid); +typedef struct map_session_data* (*HPMHOOK_pre_map_charid2sd) (int *charid); +typedef struct map_session_data* (*HPMHOOK_post_map_charid2sd) (struct map_session_data* retVal___, int charid); +typedef void (*HPMHOOK_pre_map_vforeachpc) (int ( **func ) (struct map_session_data *sd, va_list args), va_list args); +typedef void (*HPMHOOK_post_map_vforeachpc) (int ( *func ) (struct map_session_data *sd, va_list args), va_list args); +typedef void (*HPMHOOK_pre_map_vforeachmob) (int ( **func ) (struct mob_data *md, va_list args), va_list args); +typedef void (*HPMHOOK_post_map_vforeachmob) (int ( *func ) (struct mob_data *md, va_list args), va_list args); +typedef void (*HPMHOOK_pre_map_vforeachnpc) (int ( **func ) (struct npc_data *nd, va_list args), va_list args); +typedef void (*HPMHOOK_post_map_vforeachnpc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args); +typedef void (*HPMHOOK_pre_map_vforeachregen) (int ( **func ) (struct block_list *bl, va_list args), va_list args); +typedef void (*HPMHOOK_post_map_vforeachregen) (int ( *func ) (struct block_list *bl, va_list args), va_list args); +typedef void (*HPMHOOK_pre_map_vforeachiddb) (int ( **func ) (struct block_list *bl, va_list args), va_list args); +typedef void (*HPMHOOK_post_map_vforeachiddb) (int ( *func ) (struct block_list *bl, va_list args), va_list args); +typedef int (*HPMHOOK_pre_map_vforeachinrange) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachinrange) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachinshootrange) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachinshootrange) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachinarea) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachinarea) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforcountinrange) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *count, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforcountinrange) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int count, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforcountinarea) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforcountinarea) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachinmovearea) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachinmovearea) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int16 dx, int16 dy, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachincell) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachincell) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x, int16 y, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachinpath) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachinpath) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, va_list ap); +typedef int (*HPMHOOK_pre_map_vforeachinmap) (int ( **func ) (struct block_list *, va_list), int16 *m, int *type, va_list args); +typedef int (*HPMHOOK_post_map_vforeachinmap) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int type, va_list args); +typedef int (*HPMHOOK_pre_map_vforeachininstance) (int ( **func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap); +typedef int (*HPMHOOK_post_map_vforeachininstance) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 instance_id, int type, va_list ap); +typedef struct map_session_data* (*HPMHOOK_pre_map_id2sd) (int *id); +typedef struct map_session_data* (*HPMHOOK_post_map_id2sd) (struct map_session_data* retVal___, int id); +typedef struct npc_data* (*HPMHOOK_pre_map_id2nd) (int *id); +typedef struct npc_data* (*HPMHOOK_post_map_id2nd) (struct npc_data* retVal___, int id); +typedef struct mob_data* (*HPMHOOK_pre_map_id2md) (int *id); +typedef struct mob_data* (*HPMHOOK_post_map_id2md) (struct mob_data* retVal___, int id); +typedef struct flooritem_data* (*HPMHOOK_pre_map_id2fi) (int *id); +typedef struct flooritem_data* (*HPMHOOK_post_map_id2fi) (struct flooritem_data* retVal___, int id); +typedef struct chat_data* (*HPMHOOK_pre_map_id2cd) (int *id); +typedef struct chat_data* (*HPMHOOK_post_map_id2cd) (struct chat_data* retVal___, int id); +typedef struct skill_unit* (*HPMHOOK_pre_map_id2su) (int *id); +typedef struct skill_unit* (*HPMHOOK_post_map_id2su) (struct skill_unit* retVal___, int id); +typedef struct pet_data* (*HPMHOOK_pre_map_id2pd) (int *id); +typedef struct pet_data* (*HPMHOOK_post_map_id2pd) (struct pet_data* retVal___, int id); +typedef struct homun_data* (*HPMHOOK_pre_map_id2hd) (int *id); +typedef struct homun_data* (*HPMHOOK_post_map_id2hd) (struct homun_data* retVal___, int id); +typedef struct mercenary_data* (*HPMHOOK_pre_map_id2mc) (int *id); +typedef struct mercenary_data* (*HPMHOOK_post_map_id2mc) (struct mercenary_data* retVal___, int id); +typedef struct elemental_data* (*HPMHOOK_pre_map_id2ed) (int *id); +typedef struct elemental_data* (*HPMHOOK_post_map_id2ed) (struct elemental_data* retVal___, int id); +typedef struct block_list* (*HPMHOOK_pre_map_id2bl) (int *id); +typedef struct block_list* (*HPMHOOK_post_map_id2bl) (struct block_list* retVal___, int id); +typedef bool (*HPMHOOK_pre_map_blid_exists) (int *id); +typedef bool (*HPMHOOK_post_map_blid_exists) (bool retVal___, int id); +typedef int16 (*HPMHOOK_pre_map_mapindex2mapid) (unsigned short *map_index); +typedef int16 (*HPMHOOK_post_map_mapindex2mapid) (int16 retVal___, unsigned short map_index); +typedef int16 (*HPMHOOK_pre_map_mapname2mapid) (const char **name); +typedef int16 (*HPMHOOK_post_map_mapname2mapid) (int16 retVal___, const char *name); +typedef int (*HPMHOOK_pre_map_mapname2ipport) (unsigned short *name, uint32 **ip, uint16 **port); +typedef int (*HPMHOOK_post_map_mapname2ipport) (int retVal___, unsigned short name, uint32 *ip, uint16 *port); +typedef int (*HPMHOOK_pre_map_setipport) (unsigned short *map_index, uint32 *ip, uint16 *port); +typedef int (*HPMHOOK_post_map_setipport) (int retVal___, unsigned short map_index, uint32 ip, uint16 port); +typedef int (*HPMHOOK_pre_map_eraseipport) (unsigned short *map_index, uint32 *ip, uint16 *port); +typedef int (*HPMHOOK_post_map_eraseipport) (int retVal___, unsigned short map_index, uint32 ip, uint16 port); +typedef int (*HPMHOOK_pre_map_eraseallipport) (void); +typedef int (*HPMHOOK_post_map_eraseallipport) (int retVal___); +typedef void (*HPMHOOK_pre_map_addiddb) (struct block_list **bl); +typedef void (*HPMHOOK_post_map_addiddb) (struct block_list *bl); +typedef void (*HPMHOOK_pre_map_deliddb) (struct block_list **bl); +typedef void (*HPMHOOK_post_map_deliddb) (struct block_list *bl); +typedef struct map_session_data* (*HPMHOOK_pre_map_nick2sd) (const char **nick); +typedef struct map_session_data* (*HPMHOOK_post_map_nick2sd) (struct map_session_data* retVal___, const char *nick); +typedef struct mob_data* (*HPMHOOK_pre_map_getmob_boss) (int16 *m); +typedef struct mob_data* (*HPMHOOK_post_map_getmob_boss) (struct mob_data* retVal___, int16 m); +typedef struct mob_data* (*HPMHOOK_pre_map_id2boss) (int *id); +typedef struct mob_data* (*HPMHOOK_post_map_id2boss) (struct mob_data* retVal___, int id); +typedef uint32 (*HPMHOOK_pre_map_race_id2mask) (int *race); +typedef uint32 (*HPMHOOK_post_map_race_id2mask) (uint32 retVal___, int race); +typedef void (*HPMHOOK_pre_map_reloadnpc) (bool *clear); +typedef void (*HPMHOOK_post_map_reloadnpc) (bool clear); +typedef int (*HPMHOOK_pre_map_check_dir) (int *s_dir, int *t_dir); +typedef int (*HPMHOOK_post_map_check_dir) (int retVal___, int s_dir, int t_dir); +typedef uint8 (*HPMHOOK_pre_map_calc_dir) (struct block_list **src, int16 *x, int16 *y); +typedef uint8 (*HPMHOOK_post_map_calc_dir) (uint8 retVal___, struct block_list *src, int16 x, int16 y); +typedef int (*HPMHOOK_pre_map_random_dir) (struct block_list **bl, short **x, short **y); +typedef int (*HPMHOOK_post_map_random_dir) (int retVal___, struct block_list *bl, short *x, short *y); +typedef int (*HPMHOOK_pre_map_cleanup_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_map_cleanup_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_map_delmap) (char **mapname); +typedef int (*HPMHOOK_post_map_delmap) (int retVal___, char *mapname); +typedef void (*HPMHOOK_pre_map_flags_init) (void); +typedef void (*HPMHOOK_post_map_flags_init) (void); +typedef bool (*HPMHOOK_pre_map_iwall_set) (int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char **wall_name); +typedef bool (*HPMHOOK_post_map_iwall_set) (bool retVal___, int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char *wall_name); +typedef void (*HPMHOOK_pre_map_iwall_get) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_map_iwall_get) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_map_iwall_remove) (const char **wall_name); +typedef void (*HPMHOOK_post_map_iwall_remove) (const char *wall_name); +typedef int (*HPMHOOK_pre_map_addmobtolist) (unsigned short *m, struct spawn_data **spawn); +typedef int (*HPMHOOK_post_map_addmobtolist) (int retVal___, unsigned short m, struct spawn_data *spawn); +typedef void (*HPMHOOK_pre_map_spawnmobs) (int16 *m); +typedef void (*HPMHOOK_post_map_spawnmobs) (int16 m); +typedef void (*HPMHOOK_pre_map_removemobs) (int16 *m); +typedef void (*HPMHOOK_post_map_removemobs) (int16 m); +typedef void (*HPMHOOK_pre_map_addmap2db) (struct map_data **m); +typedef void (*HPMHOOK_post_map_addmap2db) (struct map_data *m); +typedef void (*HPMHOOK_pre_map_removemapdb) (struct map_data **m); +typedef void (*HPMHOOK_post_map_removemapdb) (struct map_data *m); +typedef void (*HPMHOOK_pre_map_clean) (int *i); +typedef void (*HPMHOOK_post_map_clean) (int i); +typedef void (*HPMHOOK_pre_map_do_shutdown) (void); +typedef void (*HPMHOOK_post_map_do_shutdown) (void); +typedef int (*HPMHOOK_pre_map_freeblock_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_map_freeblock_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_map_searchrandfreecell) (int16 *m, const struct block_list **bl, int16 **x, int16 **y, int *stack); +typedef int (*HPMHOOK_post_map_searchrandfreecell) (int retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int stack); +typedef int (*HPMHOOK_pre_map_count_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_map_count_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef struct DBData (*HPMHOOK_pre_map_create_charid2nick) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_map_create_charid2nick) (struct DBData retVal___, union DBKey key, va_list args); +typedef int (*HPMHOOK_pre_map_removemobs_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_map_removemobs_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef struct mapcell (*HPMHOOK_pre_map_gat2cell) (int *gat); +typedef struct mapcell (*HPMHOOK_post_map_gat2cell) (struct mapcell retVal___, int gat); +typedef int (*HPMHOOK_pre_map_cell2gat) (struct mapcell *cell); +typedef int (*HPMHOOK_post_map_cell2gat) (int retVal___, struct mapcell cell); +typedef int (*HPMHOOK_pre_map_getcellp) (struct map_data **m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); +typedef int (*HPMHOOK_post_map_getcellp) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); +typedef void (*HPMHOOK_pre_map_setcell) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag); +typedef void (*HPMHOOK_post_map_setcell) (int16 m, int16 x, int16 y, cell_t cell, bool flag); +typedef int (*HPMHOOK_pre_map_sub_getcellp) (struct map_data **m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); +typedef int (*HPMHOOK_post_map_sub_getcellp) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); +typedef void (*HPMHOOK_pre_map_sub_setcell) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag); +typedef void (*HPMHOOK_post_map_sub_setcell) (int16 m, int16 x, int16 y, cell_t cell, bool flag); +typedef void (*HPMHOOK_pre_map_iwall_nextxy) (int16 *x, int16 *y, int8 *dir, int *pos, int16 **x1, int16 **y1); +typedef void (*HPMHOOK_post_map_iwall_nextxy) (int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1); +typedef struct DBData (*HPMHOOK_pre_map_create_map_data_other_server) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_map_create_map_data_other_server) (struct DBData retVal___, union DBKey key, va_list args); +typedef int (*HPMHOOK_pre_map_eraseallipport_sub) (union DBKey *key, struct DBData **data, va_list va); +typedef int (*HPMHOOK_post_map_eraseallipport_sub) (int retVal___, union DBKey key, struct DBData *data, va_list va); +typedef char* (*HPMHOOK_pre_map_init_mapcache) (FILE **fp); +typedef char* (*HPMHOOK_post_map_init_mapcache) (char* retVal___, FILE *fp); +typedef int (*HPMHOOK_pre_map_readfromcache) (struct map_data **m, char **buffer); +typedef int (*HPMHOOK_post_map_readfromcache) (int retVal___, struct map_data *m, char *buffer); +typedef int (*HPMHOOK_pre_map_addmap) (const char **mapname); +typedef int (*HPMHOOK_post_map_addmap) (int retVal___, const char *mapname); +typedef void (*HPMHOOK_pre_map_delmapid) (int *id); +typedef void (*HPMHOOK_post_map_delmapid) (int id); +typedef void (*HPMHOOK_pre_map_zone_db_clear) (void); +typedef void (*HPMHOOK_post_map_zone_db_clear) (void); +typedef void (*HPMHOOK_pre_map_list_final) (void); +typedef void (*HPMHOOK_post_map_list_final) (void); +typedef int (*HPMHOOK_pre_map_waterheight) (char **mapname); +typedef int (*HPMHOOK_post_map_waterheight) (int retVal___, char *mapname); +typedef int (*HPMHOOK_pre_map_readgat) (struct map_data **m); +typedef int (*HPMHOOK_post_map_readgat) (int retVal___, struct map_data *m); +typedef int (*HPMHOOK_pre_map_readallmaps) (void); +typedef int (*HPMHOOK_post_map_readallmaps) (int retVal___); +typedef int (*HPMHOOK_pre_map_config_read) (char **cfgName); +typedef int (*HPMHOOK_post_map_config_read) (int retVal___, char *cfgName); +typedef int (*HPMHOOK_pre_map_config_read_sub) (char **cfgName); +typedef int (*HPMHOOK_post_map_config_read_sub) (int retVal___, char *cfgName); +typedef void (*HPMHOOK_pre_map_reloadnpc_sub) (char **cfgName); +typedef void (*HPMHOOK_post_map_reloadnpc_sub) (char *cfgName); +typedef int (*HPMHOOK_pre_map_inter_config_read) (char **cfgName); +typedef int (*HPMHOOK_post_map_inter_config_read) (int retVal___, char *cfgName); +typedef int (*HPMHOOK_pre_map_sql_init) (void); +typedef int (*HPMHOOK_post_map_sql_init) (int retVal___); +typedef int (*HPMHOOK_pre_map_sql_close) (void); +typedef int (*HPMHOOK_post_map_sql_close) (int retVal___); +typedef bool (*HPMHOOK_pre_map_zone_mf_cache) (int *m, char **flag, char **params); +typedef bool (*HPMHOOK_post_map_zone_mf_cache) (bool retVal___, int m, char *flag, char *params); +typedef unsigned short (*HPMHOOK_pre_map_zone_str2itemid) (const char **name); +typedef unsigned short (*HPMHOOK_post_map_zone_str2itemid) (unsigned short retVal___, const char *name); +typedef unsigned short (*HPMHOOK_pre_map_zone_str2skillid) (const char **name); +typedef unsigned short (*HPMHOOK_post_map_zone_str2skillid) (unsigned short retVal___, const char *name); +typedef enum bl_type (*HPMHOOK_pre_map_zone_bl_type) (const char **entry, enum map_zone_skill_subtype **subtype); +typedef enum bl_type (*HPMHOOK_post_map_zone_bl_type) (enum bl_type retVal___, const char *entry, enum map_zone_skill_subtype *subtype); +typedef void (*HPMHOOK_pre_map_read_zone_db) (void); +typedef void (*HPMHOOK_post_map_read_zone_db) (void); +typedef int (*HPMHOOK_pre_map_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_map_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_map_nick_db_final) (union DBKey *key, struct DBData **data, va_list args); +typedef int (*HPMHOOK_post_map_nick_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list args); +typedef int (*HPMHOOK_pre_map_cleanup_db_sub) (union DBKey *key, struct DBData **data, va_list va); +typedef int (*HPMHOOK_post_map_cleanup_db_sub) (int retVal___, union DBKey key, struct DBData *data, va_list va); +typedef int (*HPMHOOK_pre_map_abort_sub) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_map_abort_sub) (int retVal___, struct map_session_data *sd, va_list ap); +typedef void (*HPMHOOK_pre_map_update_cell_bl) (struct block_list **bl, bool *increase); +typedef void (*HPMHOOK_post_map_update_cell_bl) (struct block_list *bl, bool increase); +typedef int (*HPMHOOK_pre_map_get_new_bonus_id) (void); +typedef int (*HPMHOOK_post_map_get_new_bonus_id) (int retVal___); +typedef void (*HPMHOOK_pre_map_add_questinfo) (int *m, struct questinfo **qi); +typedef void (*HPMHOOK_post_map_add_questinfo) (int m, struct questinfo *qi); +typedef bool (*HPMHOOK_pre_map_remove_questinfo) (int *m, struct npc_data **nd); +typedef bool (*HPMHOOK_post_map_remove_questinfo) (bool retVal___, int m, struct npc_data *nd); +typedef struct map_zone_data* (*HPMHOOK_pre_map_merge_zone) (struct map_zone_data **main, struct map_zone_data **other); +typedef struct map_zone_data* (*HPMHOOK_post_map_merge_zone) (struct map_zone_data* retVal___, struct map_zone_data *main, struct map_zone_data *other); +typedef void (*HPMHOOK_pre_map_zone_clear_single) (struct map_zone_data **zone); +typedef void (*HPMHOOK_post_map_zone_clear_single) (struct map_zone_data *zone); +#endif // MAP_MAP_H +#ifdef CHAR_MAPIF_H /* mapif */ +typedef void (*HPMHOOK_pre_mapif_ban) (int *id, unsigned int *flag, int *status); +typedef void (*HPMHOOK_post_mapif_ban) (int id, unsigned int flag, int status); +typedef void (*HPMHOOK_pre_mapif_server_init) (int *id); +typedef void (*HPMHOOK_post_mapif_server_init) (int id); +typedef void (*HPMHOOK_pre_mapif_server_destroy) (int *id); +typedef void (*HPMHOOK_post_mapif_server_destroy) (int id); +typedef void (*HPMHOOK_pre_mapif_server_reset) (int *id); +typedef void (*HPMHOOK_post_mapif_server_reset) (int id); +typedef void (*HPMHOOK_pre_mapif_on_disconnect) (int *id); +typedef void (*HPMHOOK_post_mapif_on_disconnect) (int id); +typedef void (*HPMHOOK_pre_mapif_on_parse_accinfo) (int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd); +typedef void (*HPMHOOK_post_mapif_on_parse_accinfo) (int account_id, int u_fd, int u_aid, int u_group, int map_fd); +typedef void (*HPMHOOK_pre_mapif_char_ban) (int *char_id, time_t *timestamp); +typedef void (*HPMHOOK_post_mapif_char_ban) (int char_id, time_t timestamp); +typedef int (*HPMHOOK_pre_mapif_sendall) (const unsigned char **buf, unsigned int *len); +typedef int (*HPMHOOK_post_mapif_sendall) (int retVal___, const unsigned char *buf, unsigned int len); +typedef int (*HPMHOOK_pre_mapif_sendallwos) (int *sfd, unsigned char **buf, unsigned int *len); +typedef int (*HPMHOOK_post_mapif_sendallwos) (int retVal___, int sfd, unsigned char *buf, unsigned int len); +typedef int (*HPMHOOK_pre_mapif_send) (int *fd, unsigned char **buf, unsigned int *len); +typedef int (*HPMHOOK_post_mapif_send) (int retVal___, int fd, unsigned char *buf, unsigned int len); +typedef void (*HPMHOOK_pre_mapif_send_users_count) (int *users); +typedef void (*HPMHOOK_post_mapif_send_users_count) (int users); +typedef void (*HPMHOOK_pre_mapif_auction_message) (int *char_id, unsigned char *result); +typedef void (*HPMHOOK_post_mapif_auction_message) (int char_id, unsigned char result); +typedef void (*HPMHOOK_pre_mapif_auction_sendlist) (int *fd, int *char_id, short *count, short *pages, unsigned char **buf); +typedef void (*HPMHOOK_post_mapif_auction_sendlist) (int fd, int char_id, short count, short pages, unsigned char *buf); +typedef void (*HPMHOOK_pre_mapif_parse_auction_requestlist) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_auction_requestlist) (int fd); +typedef void (*HPMHOOK_pre_mapif_auction_register) (int *fd, struct auction_data **auction); +typedef void (*HPMHOOK_post_mapif_auction_register) (int fd, struct auction_data *auction); +typedef void (*HPMHOOK_pre_mapif_parse_auction_register) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_auction_register) (int fd); +typedef void (*HPMHOOK_pre_mapif_auction_cancel) (int *fd, int *char_id, unsigned char *result); +typedef void (*HPMHOOK_post_mapif_auction_cancel) (int fd, int char_id, unsigned char result); +typedef void (*HPMHOOK_pre_mapif_parse_auction_cancel) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_auction_cancel) (int fd); +typedef void (*HPMHOOK_pre_mapif_auction_close) (int *fd, int *char_id, unsigned char *result); +typedef void (*HPMHOOK_post_mapif_auction_close) (int fd, int char_id, unsigned char result); +typedef void (*HPMHOOK_pre_mapif_parse_auction_close) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_auction_close) (int fd); +typedef void (*HPMHOOK_pre_mapif_auction_bid) (int *fd, int *char_id, int *bid, unsigned char *result); +typedef void (*HPMHOOK_post_mapif_auction_bid) (int fd, int char_id, int bid, unsigned char result); +typedef void (*HPMHOOK_pre_mapif_parse_auction_bid) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_auction_bid) (int fd); +typedef bool (*HPMHOOK_pre_mapif_elemental_create) (struct s_elemental **ele); +typedef bool (*HPMHOOK_post_mapif_elemental_create) (bool retVal___, struct s_elemental *ele); +typedef bool (*HPMHOOK_pre_mapif_elemental_save) (const struct s_elemental **ele); +typedef bool (*HPMHOOK_post_mapif_elemental_save) (bool retVal___, const struct s_elemental *ele); +typedef bool (*HPMHOOK_pre_mapif_elemental_load) (int *ele_id, int *char_id, struct s_elemental **ele); +typedef bool (*HPMHOOK_post_mapif_elemental_load) (bool retVal___, int ele_id, int char_id, struct s_elemental *ele); +typedef bool (*HPMHOOK_pre_mapif_elemental_delete) (int *ele_id); +typedef bool (*HPMHOOK_post_mapif_elemental_delete) (bool retVal___, int ele_id); +typedef void (*HPMHOOK_pre_mapif_elemental_send) (int *fd, struct s_elemental **ele, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_elemental_send) (int fd, struct s_elemental *ele, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_elemental_create) (int *fd, const struct s_elemental **ele); +typedef void (*HPMHOOK_post_mapif_parse_elemental_create) (int fd, const struct s_elemental *ele); +typedef void (*HPMHOOK_pre_mapif_parse_elemental_load) (int *fd, int *ele_id, int *char_id); +typedef void (*HPMHOOK_post_mapif_parse_elemental_load) (int fd, int ele_id, int char_id); +typedef void (*HPMHOOK_pre_mapif_elemental_deleted) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_elemental_deleted) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_elemental_delete) (int *fd, int *ele_id); +typedef void (*HPMHOOK_post_mapif_parse_elemental_delete) (int fd, int ele_id); +typedef void (*HPMHOOK_pre_mapif_elemental_saved) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_elemental_saved) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_elemental_save) (int *fd, const struct s_elemental **ele); +typedef void (*HPMHOOK_post_mapif_parse_elemental_save) (int fd, const struct s_elemental *ele); +typedef int (*HPMHOOK_pre_mapif_guild_created) (int *fd, int *account_id, struct guild **g); +typedef int (*HPMHOOK_post_mapif_guild_created) (int retVal___, int fd, int account_id, struct guild *g); +typedef int (*HPMHOOK_pre_mapif_guild_noinfo) (int *fd, int *guild_id); +typedef int (*HPMHOOK_post_mapif_guild_noinfo) (int retVal___, int fd, int guild_id); +typedef int (*HPMHOOK_pre_mapif_guild_info) (int *fd, struct guild **g); +typedef int (*HPMHOOK_post_mapif_guild_info) (int retVal___, int fd, struct guild *g); +typedef int (*HPMHOOK_pre_mapif_guild_memberadded) (int *fd, int *guild_id, int *account_id, int *char_id, int *flag); +typedef int (*HPMHOOK_post_mapif_guild_memberadded) (int retVal___, int fd, int guild_id, int account_id, int char_id, int flag); +typedef int (*HPMHOOK_pre_mapif_guild_withdraw) (int *guild_id, int *account_id, int *char_id, int *flag, const char **name, const char **mes); +typedef int (*HPMHOOK_post_mapif_guild_withdraw) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes); +typedef int (*HPMHOOK_pre_mapif_guild_memberinfoshort) (struct guild **g, int *idx); +typedef int (*HPMHOOK_post_mapif_guild_memberinfoshort) (int retVal___, struct guild *g, int idx); +typedef int (*HPMHOOK_pre_mapif_guild_broken) (int *guild_id, int *flag); +typedef int (*HPMHOOK_post_mapif_guild_broken) (int retVal___, int guild_id, int flag); +typedef int (*HPMHOOK_pre_mapif_guild_message) (int *guild_id, int *account_id, const char **mes, int *len, int *sfd); +typedef int (*HPMHOOK_post_mapif_guild_message) (int retVal___, int guild_id, int account_id, const char *mes, int len, int sfd); +typedef int (*HPMHOOK_pre_mapif_guild_basicinfochanged) (int *guild_id, int *type, const void **data, int *len); +typedef int (*HPMHOOK_post_mapif_guild_basicinfochanged) (int retVal___, int guild_id, int type, const void *data, int len); +typedef int (*HPMHOOK_pre_mapif_guild_memberinfochanged) (int *guild_id, int *account_id, int *char_id, int *type, const void **data, int *len); +typedef int (*HPMHOOK_post_mapif_guild_memberinfochanged) (int retVal___, int guild_id, int account_id, int char_id, int type, const void *data, int len); +typedef int (*HPMHOOK_pre_mapif_guild_skillupack) (int *guild_id, uint16 *skill_id, int *account_id); +typedef int (*HPMHOOK_post_mapif_guild_skillupack) (int retVal___, int guild_id, uint16 skill_id, int account_id); +typedef int (*HPMHOOK_pre_mapif_guild_alliance) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char **name1, const char **name2); +typedef int (*HPMHOOK_post_mapif_guild_alliance) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2); +typedef int (*HPMHOOK_pre_mapif_guild_position) (struct guild **g, int *idx); +typedef int (*HPMHOOK_post_mapif_guild_position) (int retVal___, struct guild *g, int idx); +typedef int (*HPMHOOK_pre_mapif_guild_notice) (struct guild **g); +typedef int (*HPMHOOK_post_mapif_guild_notice) (int retVal___, struct guild *g); +typedef int (*HPMHOOK_pre_mapif_guild_emblem) (struct guild **g); +typedef int (*HPMHOOK_post_mapif_guild_emblem) (int retVal___, struct guild *g); +typedef int (*HPMHOOK_pre_mapif_guild_master_changed) (struct guild **g, int *aid, int *cid); +typedef int (*HPMHOOK_post_mapif_guild_master_changed) (int retVal___, struct guild *g, int aid, int cid); +typedef int (*HPMHOOK_pre_mapif_guild_castle_dataload) (int *fd, int *sz, const int **castle_ids); +typedef int (*HPMHOOK_post_mapif_guild_castle_dataload) (int retVal___, int fd, int sz, const int *castle_ids); +typedef int (*HPMHOOK_pre_mapif_parse_CreateGuild) (int *fd, int *account_id, const char **name, const struct guild_member **master); +typedef int (*HPMHOOK_post_mapif_parse_CreateGuild) (int retVal___, int fd, int account_id, const char *name, const struct guild_member *master); +typedef int (*HPMHOOK_pre_mapif_parse_GuildInfo) (int *fd, int *guild_id); +typedef int (*HPMHOOK_post_mapif_parse_GuildInfo) (int retVal___, int fd, int guild_id); +typedef int (*HPMHOOK_pre_mapif_parse_GuildAddMember) (int *fd, int *guild_id, const struct guild_member **m); +typedef int (*HPMHOOK_post_mapif_parse_GuildAddMember) (int retVal___, int fd, int guild_id, const struct guild_member *m); +typedef int (*HPMHOOK_pre_mapif_parse_GuildLeave) (int *fd, int *guild_id, int *account_id, int *char_id, int *flag, const char **mes); +typedef int (*HPMHOOK_post_mapif_parse_GuildLeave) (int retVal___, int fd, int guild_id, int account_id, int char_id, int flag, const char *mes); +typedef int (*HPMHOOK_pre_mapif_parse_GuildChangeMemberInfoShort) (int *fd, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); +typedef int (*HPMHOOK_post_mapif_parse_GuildChangeMemberInfoShort) (int retVal___, int fd, int guild_id, int account_id, int char_id, int online, int lv, int class_); +typedef int (*HPMHOOK_pre_mapif_parse_BreakGuild) (int *fd, int *guild_id); +typedef int (*HPMHOOK_post_mapif_parse_BreakGuild) (int retVal___, int fd, int guild_id); +typedef int (*HPMHOOK_pre_mapif_parse_GuildMessage) (int *fd, int *guild_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_mapif_parse_GuildMessage) (int retVal___, int fd, int guild_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_mapif_parse_GuildBasicInfoChange) (int *fd, int *guild_id, int *type, const void **data, int *len); +typedef int (*HPMHOOK_post_mapif_parse_GuildBasicInfoChange) (int retVal___, int fd, int guild_id, int type, const void *data, int len); +typedef int (*HPMHOOK_pre_mapif_parse_GuildMemberInfoChange) (int *fd, int *guild_id, int *account_id, int *char_id, int *type, const char **data, int *len); +typedef int (*HPMHOOK_post_mapif_parse_GuildMemberInfoChange) (int retVal___, int fd, int guild_id, int account_id, int char_id, int type, const char *data, int len); +typedef int (*HPMHOOK_pre_mapif_parse_GuildPosition) (int *fd, int *guild_id, int *idx, const struct guild_position **p); +typedef int (*HPMHOOK_post_mapif_parse_GuildPosition) (int retVal___, int fd, int guild_id, int idx, const struct guild_position *p); +typedef int (*HPMHOOK_pre_mapif_parse_GuildSkillUp) (int *fd, int *guild_id, uint16 *skill_id, int *account_id, int *max); +typedef int (*HPMHOOK_post_mapif_parse_GuildSkillUp) (int retVal___, int fd, int guild_id, uint16 skill_id, int account_id, int max); +typedef int (*HPMHOOK_pre_mapif_parse_GuildDeleteAlliance) (struct guild **g, int *guild_id, int *account_id1, int *account_id2, int *flag); +typedef int (*HPMHOOK_post_mapif_parse_GuildDeleteAlliance) (int retVal___, struct guild *g, int guild_id, int account_id1, int account_id2, int flag); +typedef int (*HPMHOOK_pre_mapif_parse_GuildAlliance) (int *fd, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag); +typedef int (*HPMHOOK_post_mapif_parse_GuildAlliance) (int retVal___, int fd, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag); +typedef int (*HPMHOOK_pre_mapif_parse_GuildNotice) (int *fd, int *guild_id, const char **mes1, const char **mes2); +typedef int (*HPMHOOK_post_mapif_parse_GuildNotice) (int retVal___, int fd, int guild_id, const char *mes1, const char *mes2); +typedef int (*HPMHOOK_pre_mapif_parse_GuildEmblem) (int *fd, int *len, int *guild_id, int *dummy, const char **data); +typedef int (*HPMHOOK_post_mapif_parse_GuildEmblem) (int retVal___, int fd, int len, int guild_id, int dummy, const char *data); +typedef int (*HPMHOOK_pre_mapif_parse_GuildCastleDataLoad) (int *fd, int *len, const int **castle_ids); +typedef int (*HPMHOOK_post_mapif_parse_GuildCastleDataLoad) (int retVal___, int fd, int len, const int *castle_ids); +typedef int (*HPMHOOK_pre_mapif_parse_GuildCastleDataSave) (int *fd, int *castle_id, int *index, int *value); +typedef int (*HPMHOOK_post_mapif_parse_GuildCastleDataSave) (int retVal___, int fd, int castle_id, int index, int value); +typedef int (*HPMHOOK_pre_mapif_parse_GuildMasterChange) (int *fd, int *guild_id, const char **name, int *len); +typedef int (*HPMHOOK_post_mapif_parse_GuildMasterChange) (int retVal___, int fd, int guild_id, const char *name, int len); +typedef void (*HPMHOOK_pre_mapif_homunculus_created) (int *fd, int *account_id, const struct s_homunculus **sh, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_homunculus_created) (int fd, int account_id, const struct s_homunculus *sh, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_homunculus_deleted) (int *fd, int *flag); +typedef void (*HPMHOOK_post_mapif_homunculus_deleted) (int fd, int flag); +typedef void (*HPMHOOK_pre_mapif_homunculus_loaded) (int *fd, int *account_id, struct s_homunculus **hd); +typedef void (*HPMHOOK_post_mapif_homunculus_loaded) (int fd, int account_id, struct s_homunculus *hd); +typedef void (*HPMHOOK_pre_mapif_homunculus_saved) (int *fd, int *account_id, bool *flag); +typedef void (*HPMHOOK_post_mapif_homunculus_saved) (int fd, int account_id, bool flag); +typedef void (*HPMHOOK_pre_mapif_homunculus_renamed) (int *fd, int *account_id, int *char_id, unsigned char *flag, const char **name); +typedef void (*HPMHOOK_post_mapif_homunculus_renamed) (int fd, int account_id, int char_id, unsigned char flag, const char *name); +typedef bool (*HPMHOOK_pre_mapif_homunculus_create) (struct s_homunculus **hd); +typedef bool (*HPMHOOK_post_mapif_homunculus_create) (bool retVal___, struct s_homunculus *hd); +typedef bool (*HPMHOOK_pre_mapif_homunculus_save) (const struct s_homunculus **hd); +typedef bool (*HPMHOOK_post_mapif_homunculus_save) (bool retVal___, const struct s_homunculus *hd); +typedef bool (*HPMHOOK_pre_mapif_homunculus_load) (int *homun_id, struct s_homunculus **hd); +typedef bool (*HPMHOOK_post_mapif_homunculus_load) (bool retVal___, int homun_id, struct s_homunculus *hd); +typedef bool (*HPMHOOK_pre_mapif_homunculus_delete) (int *homun_id); +typedef bool (*HPMHOOK_post_mapif_homunculus_delete) (bool retVal___, int homun_id); +typedef bool (*HPMHOOK_pre_mapif_homunculus_rename) (const char **name); +typedef bool (*HPMHOOK_post_mapif_homunculus_rename) (bool retVal___, const char *name); +typedef void (*HPMHOOK_pre_mapif_parse_homunculus_create) (int *fd, int *len, int *account_id, const struct s_homunculus **phd); +typedef void (*HPMHOOK_post_mapif_parse_homunculus_create) (int fd, int len, int account_id, const struct s_homunculus *phd); +typedef void (*HPMHOOK_pre_mapif_parse_homunculus_delete) (int *fd, int *homun_id); +typedef void (*HPMHOOK_post_mapif_parse_homunculus_delete) (int fd, int homun_id); +typedef void (*HPMHOOK_pre_mapif_parse_homunculus_load) (int *fd, int *account_id, int *homun_id); +typedef void (*HPMHOOK_post_mapif_parse_homunculus_load) (int fd, int account_id, int homun_id); +typedef void (*HPMHOOK_pre_mapif_parse_homunculus_save) (int *fd, int *len, int *account_id, const struct s_homunculus **phd); +typedef void (*HPMHOOK_post_mapif_parse_homunculus_save) (int fd, int len, int account_id, const struct s_homunculus *phd); +typedef void (*HPMHOOK_pre_mapif_parse_homunculus_rename) (int *fd, int *account_id, int *char_id, const char **name); +typedef void (*HPMHOOK_post_mapif_parse_homunculus_rename) (int fd, int account_id, int char_id, const char *name); +typedef void (*HPMHOOK_pre_mapif_mail_sendinbox) (int *fd, int *char_id, unsigned char *flag, struct mail_data **md); +typedef void (*HPMHOOK_post_mapif_mail_sendinbox) (int fd, int char_id, unsigned char flag, struct mail_data *md); +typedef void (*HPMHOOK_pre_mapif_parse_mail_requestinbox) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_requestinbox) (int fd); +typedef void (*HPMHOOK_pre_mapif_parse_mail_read) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_read) (int fd); +typedef void (*HPMHOOK_pre_mapif_mail_sendattach) (int *fd, int *char_id, struct mail_message **msg); +typedef void (*HPMHOOK_post_mapif_mail_sendattach) (int fd, int char_id, struct mail_message *msg); +typedef void (*HPMHOOK_pre_mapif_mail_getattach) (int *fd, int *char_id, int *mail_id); +typedef void (*HPMHOOK_post_mapif_mail_getattach) (int fd, int char_id, int mail_id); +typedef void (*HPMHOOK_pre_mapif_parse_mail_getattach) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_getattach) (int fd); +typedef void (*HPMHOOK_pre_mapif_mail_delete) (int *fd, int *char_id, int *mail_id, bool *failed); +typedef void (*HPMHOOK_post_mapif_mail_delete) (int fd, int char_id, int mail_id, bool failed); +typedef void (*HPMHOOK_pre_mapif_parse_mail_delete) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_delete) (int fd); +typedef void (*HPMHOOK_pre_mapif_mail_new) (struct mail_message **msg); +typedef void (*HPMHOOK_post_mapif_mail_new) (struct mail_message *msg); +typedef void (*HPMHOOK_pre_mapif_mail_return) (int *fd, int *char_id, int *mail_id, int *new_mail); +typedef void (*HPMHOOK_post_mapif_mail_return) (int fd, int char_id, int mail_id, int new_mail); +typedef void (*HPMHOOK_pre_mapif_parse_mail_return) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_return) (int fd); +typedef void (*HPMHOOK_pre_mapif_mail_send) (int *fd, struct mail_message **msg); +typedef void (*HPMHOOK_post_mapif_mail_send) (int fd, struct mail_message *msg); +typedef void (*HPMHOOK_pre_mapif_parse_mail_send) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_mail_send) (int fd); +typedef bool (*HPMHOOK_pre_mapif_mercenary_create) (struct s_mercenary **merc); +typedef bool (*HPMHOOK_post_mapif_mercenary_create) (bool retVal___, struct s_mercenary *merc); +typedef bool (*HPMHOOK_pre_mapif_mercenary_save) (const struct s_mercenary **merc); +typedef bool (*HPMHOOK_post_mapif_mercenary_save) (bool retVal___, const struct s_mercenary *merc); +typedef bool (*HPMHOOK_pre_mapif_mercenary_load) (int *merc_id, int *char_id, struct s_mercenary **merc); +typedef bool (*HPMHOOK_post_mapif_mercenary_load) (bool retVal___, int merc_id, int char_id, struct s_mercenary *merc); +typedef bool (*HPMHOOK_pre_mapif_mercenary_delete) (int *merc_id); +typedef bool (*HPMHOOK_post_mapif_mercenary_delete) (bool retVal___, int merc_id); +typedef void (*HPMHOOK_pre_mapif_mercenary_send) (int *fd, struct s_mercenary **merc, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_mercenary_send) (int fd, struct s_mercenary *merc, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_mercenary_create) (int *fd, const struct s_mercenary **merc); +typedef void (*HPMHOOK_post_mapif_parse_mercenary_create) (int fd, const struct s_mercenary *merc); +typedef void (*HPMHOOK_pre_mapif_parse_mercenary_load) (int *fd, int *merc_id, int *char_id); +typedef void (*HPMHOOK_post_mapif_parse_mercenary_load) (int fd, int merc_id, int char_id); +typedef void (*HPMHOOK_pre_mapif_mercenary_deleted) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_mercenary_deleted) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_mercenary_delete) (int *fd, int *merc_id); +typedef void (*HPMHOOK_post_mapif_parse_mercenary_delete) (int fd, int merc_id); +typedef void (*HPMHOOK_pre_mapif_mercenary_saved) (int *fd, unsigned char *flag); +typedef void (*HPMHOOK_post_mapif_mercenary_saved) (int fd, unsigned char flag); +typedef void (*HPMHOOK_pre_mapif_parse_mercenary_save) (int *fd, const struct s_mercenary **merc); +typedef void (*HPMHOOK_post_mapif_parse_mercenary_save) (int fd, const struct s_mercenary *merc); +typedef int (*HPMHOOK_pre_mapif_party_created) (int *fd, int *account_id, int *char_id, struct party **p); +typedef int (*HPMHOOK_post_mapif_party_created) (int retVal___, int fd, int account_id, int char_id, struct party *p); +typedef void (*HPMHOOK_pre_mapif_party_noinfo) (int *fd, int *party_id, int *char_id); +typedef void (*HPMHOOK_post_mapif_party_noinfo) (int fd, int party_id, int char_id); +typedef void (*HPMHOOK_pre_mapif_party_info) (int *fd, struct party **p, int *char_id); +typedef void (*HPMHOOK_post_mapif_party_info) (int fd, struct party *p, int char_id); +typedef int (*HPMHOOK_pre_mapif_party_memberadded) (int *fd, int *party_id, int *account_id, int *char_id, int *flag); +typedef int (*HPMHOOK_post_mapif_party_memberadded) (int retVal___, int fd, int party_id, int account_id, int char_id, int flag); +typedef int (*HPMHOOK_pre_mapif_party_optionchanged) (int *fd, struct party **p, int *account_id, int *flag); +typedef int (*HPMHOOK_post_mapif_party_optionchanged) (int retVal___, int fd, struct party *p, int account_id, int flag); +typedef int (*HPMHOOK_pre_mapif_party_withdraw) (int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_mapif_party_withdraw) (int retVal___, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_mapif_party_membermoved) (struct party **p, int *idx); +typedef int (*HPMHOOK_post_mapif_party_membermoved) (int retVal___, struct party *p, int idx); +typedef int (*HPMHOOK_pre_mapif_party_broken) (int *party_id, int *flag); +typedef int (*HPMHOOK_post_mapif_party_broken) (int retVal___, int party_id, int flag); +typedef int (*HPMHOOK_pre_mapif_party_message) (int *party_id, int *account_id, const char **mes, int *len, int *sfd); +typedef int (*HPMHOOK_post_mapif_party_message) (int retVal___, int party_id, int account_id, const char *mes, int len, int sfd); +typedef int (*HPMHOOK_pre_mapif_parse_CreateParty) (int *fd, const char **name, int *item, int *item2, const struct party_member **leader); +typedef int (*HPMHOOK_post_mapif_parse_CreateParty) (int retVal___, int fd, const char *name, int item, int item2, const struct party_member *leader); +typedef void (*HPMHOOK_pre_mapif_parse_PartyInfo) (int *fd, int *party_id, int *char_id); +typedef void (*HPMHOOK_post_mapif_parse_PartyInfo) (int fd, int party_id, int char_id); +typedef int (*HPMHOOK_pre_mapif_parse_PartyAddMember) (int *fd, int *party_id, const struct party_member **member); +typedef int (*HPMHOOK_post_mapif_parse_PartyAddMember) (int retVal___, int fd, int party_id, const struct party_member *member); +typedef int (*HPMHOOK_pre_mapif_parse_PartyChangeOption) (int *fd, int *party_id, int *account_id, int *exp, int *item); +typedef int (*HPMHOOK_post_mapif_parse_PartyChangeOption) (int retVal___, int fd, int party_id, int account_id, int exp, int item); +typedef int (*HPMHOOK_pre_mapif_parse_PartyLeave) (int *fd, int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_mapif_parse_PartyLeave) (int retVal___, int fd, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_mapif_parse_PartyChangeMap) (int *fd, int *party_id, int *account_id, int *char_id, unsigned short *map, int *online, unsigned int *lv); +typedef int (*HPMHOOK_post_mapif_parse_PartyChangeMap) (int retVal___, int fd, int party_id, int account_id, int char_id, unsigned short map, int online, unsigned int lv); +typedef int (*HPMHOOK_pre_mapif_parse_BreakParty) (int *fd, int *party_id); +typedef int (*HPMHOOK_post_mapif_parse_BreakParty) (int retVal___, int fd, int party_id); +typedef int (*HPMHOOK_pre_mapif_parse_PartyMessage) (int *fd, int *party_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_mapif_parse_PartyMessage) (int retVal___, int fd, int party_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_mapif_parse_PartyLeaderChange) (int *fd, int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_mapif_parse_PartyLeaderChange) (int retVal___, int fd, int party_id, int account_id, int char_id); +typedef int (*HPMHOOK_pre_mapif_pet_created) (int *fd, int *account_id, struct s_pet **p); +typedef int (*HPMHOOK_post_mapif_pet_created) (int retVal___, int fd, int account_id, struct s_pet *p); +typedef int (*HPMHOOK_pre_mapif_pet_info) (int *fd, int *account_id, struct s_pet **p); +typedef int (*HPMHOOK_post_mapif_pet_info) (int retVal___, int fd, int account_id, struct s_pet *p); +typedef int (*HPMHOOK_pre_mapif_pet_noinfo) (int *fd, int *account_id); +typedef int (*HPMHOOK_post_mapif_pet_noinfo) (int retVal___, int fd, int account_id); +typedef int (*HPMHOOK_pre_mapif_save_pet_ack) (int *fd, int *account_id, int *flag); +typedef int (*HPMHOOK_post_mapif_save_pet_ack) (int retVal___, int fd, int account_id, int flag); +typedef int (*HPMHOOK_pre_mapif_delete_pet_ack) (int *fd, int *flag); +typedef int (*HPMHOOK_post_mapif_delete_pet_ack) (int retVal___, int fd, int flag); +typedef int (*HPMHOOK_pre_mapif_create_pet) (int *fd, int *account_id, int *char_id, short *pet_class, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, const char **pet_name); +typedef int (*HPMHOOK_post_mapif_create_pet) (int retVal___, int fd, int account_id, int char_id, short pet_class, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, const char *pet_name); +typedef int (*HPMHOOK_pre_mapif_load_pet) (int *fd, int *account_id, int *char_id, int *pet_id); +typedef int (*HPMHOOK_post_mapif_load_pet) (int retVal___, int fd, int account_id, int char_id, int pet_id); +typedef int (*HPMHOOK_pre_mapif_save_pet) (int *fd, int *account_id, const struct s_pet **data); +typedef int (*HPMHOOK_post_mapif_save_pet) (int retVal___, int fd, int account_id, const struct s_pet *data); +typedef int (*HPMHOOK_pre_mapif_delete_pet) (int *fd, int *pet_id); +typedef int (*HPMHOOK_post_mapif_delete_pet) (int retVal___, int fd, int pet_id); +typedef int (*HPMHOOK_pre_mapif_parse_CreatePet) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_CreatePet) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_LoadPet) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_LoadPet) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_SavePet) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_SavePet) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_DeletePet) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_DeletePet) (int retVal___, int fd); +typedef struct quest* (*HPMHOOK_pre_mapif_quests_fromsql) (int *char_id, int **count); +typedef struct quest* (*HPMHOOK_post_mapif_quests_fromsql) (struct quest* retVal___, int char_id, int *count); +typedef bool (*HPMHOOK_pre_mapif_quest_delete) (int *char_id, int *quest_id); +typedef bool (*HPMHOOK_post_mapif_quest_delete) (bool retVal___, int char_id, int quest_id); +typedef bool (*HPMHOOK_pre_mapif_quest_add) (int *char_id, struct quest *qd); +typedef bool (*HPMHOOK_post_mapif_quest_add) (bool retVal___, int char_id, struct quest qd); +typedef bool (*HPMHOOK_pre_mapif_quest_update) (int *char_id, struct quest *qd); +typedef bool (*HPMHOOK_post_mapif_quest_update) (bool retVal___, int char_id, struct quest qd); +typedef void (*HPMHOOK_pre_mapif_quest_save_ack) (int *fd, int *char_id, bool *success); +typedef void (*HPMHOOK_post_mapif_quest_save_ack) (int fd, int char_id, bool success); +typedef int (*HPMHOOK_pre_mapif_parse_quest_save) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_quest_save) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_mapif_send_quests) (int *fd, int *char_id, struct quest **tmp_questlog, int *num_quests); +typedef void (*HPMHOOK_post_mapif_send_quests) (int fd, int char_id, struct quest *tmp_questlog, int num_quests); +typedef int (*HPMHOOK_pre_mapif_parse_quest_load) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_quest_load) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_load_guild_storage) (int *fd, int *account_id, int *guild_id, char *flag); +typedef int (*HPMHOOK_post_mapif_load_guild_storage) (int retVal___, int fd, int account_id, int guild_id, char flag); +typedef int (*HPMHOOK_pre_mapif_save_guild_storage_ack) (int *fd, int *account_id, int *guild_id, int *fail); +typedef int (*HPMHOOK_post_mapif_save_guild_storage_ack) (int retVal___, int fd, int account_id, int guild_id, int fail); +typedef int (*HPMHOOK_pre_mapif_parse_LoadGuildStorage) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_LoadGuildStorage) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_SaveGuildStorage) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_SaveGuildStorage) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_itembound_ack) (int *fd, int *aid, int *guild_id); +typedef int (*HPMHOOK_post_mapif_itembound_ack) (int retVal___, int fd, int aid, int guild_id); +typedef int (*HPMHOOK_pre_mapif_parse_ItemBoundRetrieve_sub) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_ItemBoundRetrieve_sub) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_mapif_parse_ItemBoundRetrieve) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_ItemBoundRetrieve) (int fd); +typedef void (*HPMHOOK_pre_mapif_parse_accinfo) (int *fd); +typedef void (*HPMHOOK_post_mapif_parse_accinfo) (int fd); +typedef void (*HPMHOOK_pre_mapif_parse_accinfo2) (bool *success, int *map_fd, int *u_fd, int *u_aid, int *account_id, const char **userid, const char **user_pass, const char **email, const char **last_ip, const char **lastlogin, const char **pin_code, const char **birthdate, int *group_id, int *logincount, int *state); +typedef void (*HPMHOOK_post_mapif_parse_accinfo2) (bool success, int map_fd, int u_fd, int u_aid, int account_id, const char *userid, const char *user_pass, const char *email, const char *last_ip, const char *lastlogin, const char *pin_code, const char *birthdate, int group_id, int logincount, int state); +typedef int (*HPMHOOK_pre_mapif_broadcast) (const unsigned char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, int *sfd); +typedef int (*HPMHOOK_post_mapif_broadcast) (int retVal___, const unsigned char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, int sfd); +typedef int (*HPMHOOK_pre_mapif_wis_message) (struct WisData **wd); +typedef int (*HPMHOOK_post_mapif_wis_message) (int retVal___, struct WisData *wd); +typedef void (*HPMHOOK_pre_mapif_wis_response) (int *fd, const unsigned char **src, int *flag); +typedef void (*HPMHOOK_post_mapif_wis_response) (int fd, const unsigned char *src, int flag); +typedef int (*HPMHOOK_pre_mapif_wis_end) (struct WisData **wd, int *flag); +typedef int (*HPMHOOK_post_mapif_wis_end) (int retVal___, struct WisData *wd, int flag); +typedef int (*HPMHOOK_pre_mapif_account_reg_reply) (int *fd, int *account_id, int *char_id, int *type); +typedef int (*HPMHOOK_post_mapif_account_reg_reply) (int retVal___, int fd, int account_id, int char_id, int type); +typedef int (*HPMHOOK_pre_mapif_disconnectplayer) (int *fd, int *account_id, int *char_id, int *reason); +typedef int (*HPMHOOK_post_mapif_disconnectplayer) (int retVal___, int fd, int account_id, int char_id, int reason); +typedef int (*HPMHOOK_pre_mapif_parse_broadcast) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_broadcast) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_WisRequest) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_WisRequest) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_WisReply) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_WisReply) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_WisToGM) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_WisToGM) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_Registry) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_Registry) (int retVal___, int fd); +typedef int (*HPMHOOK_pre_mapif_parse_RegistryRequest) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_RegistryRequest) (int retVal___, int fd); +typedef void (*HPMHOOK_pre_mapif_namechange_ack) (int *fd, int *account_id, int *char_id, int *type, int *flag, const char **name); +typedef void (*HPMHOOK_post_mapif_namechange_ack) (int fd, int account_id, int char_id, int type, int flag, const char *name); +typedef int (*HPMHOOK_pre_mapif_parse_NameChangeRequest) (int *fd); +typedef int (*HPMHOOK_post_mapif_parse_NameChangeRequest) (int retVal___, int fd); +#endif // CHAR_MAPIF_H +#ifdef COMMON_MAPINDEX_H /* mapindex */ +typedef int (*HPMHOOK_pre_mapindex_init) (void); +typedef int (*HPMHOOK_post_mapindex_init) (int retVal___); +typedef void (*HPMHOOK_pre_mapindex_final) (void); +typedef void (*HPMHOOK_post_mapindex_final) (void); +typedef int (*HPMHOOK_pre_mapindex_addmap) (int *index, const char **name); +typedef int (*HPMHOOK_post_mapindex_addmap) (int retVal___, int index, const char *name); +typedef void (*HPMHOOK_pre_mapindex_removemap) (int *index); +typedef void (*HPMHOOK_post_mapindex_removemap) (int index); +typedef const char* (*HPMHOOK_pre_mapindex_getmapname) (const char **string, char **output); +typedef const char* (*HPMHOOK_post_mapindex_getmapname) (const char* retVal___, const char *string, char *output); +typedef const char* (*HPMHOOK_pre_mapindex_getmapname_ext) (const char **string, char **output); +typedef const char* (*HPMHOOK_post_mapindex_getmapname_ext) (const char* retVal___, const char *string, char *output); +typedef unsigned short (*HPMHOOK_pre_mapindex_name2id) (const char **p1); +typedef unsigned short (*HPMHOOK_post_mapindex_name2id) (unsigned short retVal___, const char *p1); +typedef const char* (*HPMHOOK_pre_mapindex_id2name) (uint16 *id, const char **file, int *line, const char **func); +typedef const char* (*HPMHOOK_post_mapindex_id2name) (const char* retVal___, uint16 id, const char *file, int line, const char *func); +typedef bool (*HPMHOOK_pre_mapindex_check_default) (void); +typedef bool (*HPMHOOK_post_mapindex_check_default) (bool retVal___); +#endif // COMMON_MAPINDEX_H +#ifdef MAP_MAP_H /* mapit */ +typedef struct s_mapiterator* (*HPMHOOK_pre_mapit_alloc) (enum e_mapitflags *flags, enum bl_type *types); +typedef struct s_mapiterator* (*HPMHOOK_post_mapit_alloc) (struct s_mapiterator* retVal___, enum e_mapitflags flags, enum bl_type types); +typedef void (*HPMHOOK_pre_mapit_free) (struct s_mapiterator **iter); +typedef void (*HPMHOOK_post_mapit_free) (struct s_mapiterator *iter); +typedef struct block_list* (*HPMHOOK_pre_mapit_first) (struct s_mapiterator **iter); +typedef struct block_list* (*HPMHOOK_post_mapit_first) (struct block_list* retVal___, struct s_mapiterator *iter); +typedef struct block_list* (*HPMHOOK_pre_mapit_last) (struct s_mapiterator **iter); +typedef struct block_list* (*HPMHOOK_post_mapit_last) (struct block_list* retVal___, struct s_mapiterator *iter); +typedef struct block_list* (*HPMHOOK_pre_mapit_next) (struct s_mapiterator **iter); +typedef struct block_list* (*HPMHOOK_post_mapit_next) (struct block_list* retVal___, struct s_mapiterator *iter); +typedef struct block_list* (*HPMHOOK_pre_mapit_prev) (struct s_mapiterator **iter); +typedef struct block_list* (*HPMHOOK_post_mapit_prev) (struct block_list* retVal___, struct s_mapiterator *iter); +typedef bool (*HPMHOOK_pre_mapit_exists) (struct s_mapiterator **iter); +typedef bool (*HPMHOOK_post_mapit_exists) (bool retVal___, struct s_mapiterator *iter); +#endif // MAP_MAP_H +#ifdef MAP_MAPREG_H /* mapreg */ +typedef void (*HPMHOOK_pre_mapreg_init) (void); +typedef void (*HPMHOOK_post_mapreg_init) (void); +typedef void (*HPMHOOK_pre_mapreg_final) (void); +typedef void (*HPMHOOK_post_mapreg_final) (void); +typedef int (*HPMHOOK_pre_mapreg_readreg) (int64 *uid); +typedef int (*HPMHOOK_post_mapreg_readreg) (int retVal___, int64 uid); +typedef char* (*HPMHOOK_pre_mapreg_readregstr) (int64 *uid); +typedef char* (*HPMHOOK_post_mapreg_readregstr) (char* retVal___, int64 uid); +typedef bool (*HPMHOOK_pre_mapreg_setreg) (int64 *uid, int *val); +typedef bool (*HPMHOOK_post_mapreg_setreg) (bool retVal___, int64 uid, int val); +typedef bool (*HPMHOOK_pre_mapreg_setregstr) (int64 *uid, const char **str); +typedef bool (*HPMHOOK_post_mapreg_setregstr) (bool retVal___, int64 uid, const char *str); +typedef void (*HPMHOOK_pre_mapreg_load) (void); +typedef void (*HPMHOOK_post_mapreg_load) (void); +typedef void (*HPMHOOK_pre_mapreg_save) (void); +typedef void (*HPMHOOK_post_mapreg_save) (void); +typedef int (*HPMHOOK_pre_mapreg_save_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mapreg_save_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_mapreg_destroyreg) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_mapreg_destroyreg) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_mapreg_reload) (void); +typedef void (*HPMHOOK_post_mapreg_reload) (void); +typedef bool (*HPMHOOK_pre_mapreg_config_read) (const char **w1, const char **w2); +typedef bool (*HPMHOOK_post_mapreg_config_read) (bool retVal___, const char *w1, const char *w2); +#endif // MAP_MAPREG_H +#ifdef MAP_MERCENARY_H /* mercenary */ +typedef void (*HPMHOOK_pre_mercenary_init) (bool *minimal); +typedef void (*HPMHOOK_post_mercenary_init) (bool minimal); +typedef bool (*HPMHOOK_pre_mercenary_class) (int *class_); +typedef bool (*HPMHOOK_post_mercenary_class) (bool retVal___, int class_); +typedef struct view_data* (*HPMHOOK_pre_mercenary_get_viewdata) (int *class_); +typedef struct view_data* (*HPMHOOK_post_mercenary_get_viewdata) (struct view_data* retVal___, int class_); +typedef int (*HPMHOOK_pre_mercenary_create) (struct map_session_data **sd, int *class_, unsigned int *lifetime); +typedef int (*HPMHOOK_post_mercenary_create) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime); +typedef int (*HPMHOOK_pre_mercenary_data_received) (const struct s_mercenary **merc, bool *flag); +typedef int (*HPMHOOK_post_mercenary_data_received) (int retVal___, const struct s_mercenary *merc, bool flag); +typedef int (*HPMHOOK_pre_mercenary_save) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_save) (int retVal___, struct mercenary_data *md); +typedef void (*HPMHOOK_pre_mercenary_heal) (struct mercenary_data **md, int *hp, int *sp); +typedef void (*HPMHOOK_post_mercenary_heal) (struct mercenary_data *md, int hp, int sp); +typedef int (*HPMHOOK_pre_mercenary_dead) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_dead) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_delete) (struct mercenary_data **md, int *reply); +typedef int (*HPMHOOK_post_mercenary_delete) (int retVal___, struct mercenary_data *md, int reply); +typedef void (*HPMHOOK_pre_mercenary_contract_stop) (struct mercenary_data **md); +typedef void (*HPMHOOK_post_mercenary_contract_stop) (struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_get_lifetime) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_get_lifetime) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_get_guild) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_get_guild) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_get_faith) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_get_faith) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_set_faith) (struct mercenary_data **md, int *value); +typedef int (*HPMHOOK_post_mercenary_set_faith) (int retVal___, struct mercenary_data *md, int value); +typedef int (*HPMHOOK_pre_mercenary_get_calls) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_get_calls) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_set_calls) (struct mercenary_data **md, int *value); +typedef int (*HPMHOOK_post_mercenary_set_calls) (int retVal___, struct mercenary_data *md, int value); +typedef int (*HPMHOOK_pre_mercenary_kills) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_kills) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_checkskill) (struct mercenary_data **md, uint16 *skill_id); +typedef int (*HPMHOOK_post_mercenary_checkskill) (int retVal___, struct mercenary_data *md, uint16 skill_id); +typedef int (*HPMHOOK_pre_mercenary_read_db) (void); +typedef int (*HPMHOOK_post_mercenary_read_db) (int retVal___); +typedef int (*HPMHOOK_pre_mercenary_read_skilldb) (void); +typedef int (*HPMHOOK_post_mercenary_read_skilldb) (int retVal___); +typedef int (*HPMHOOK_pre_mercenary_killbonus) (struct mercenary_data **md); +typedef int (*HPMHOOK_post_mercenary_killbonus) (int retVal___, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_mercenary_search_index) (int *class_); +typedef int (*HPMHOOK_post_mercenary_search_index) (int retVal___, int class_); +typedef int (*HPMHOOK_pre_mercenary_contract_end_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mercenary_contract_end_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef bool (*HPMHOOK_pre_mercenary_read_db_sub) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_mercenary_read_db_sub) (bool retVal___, char *str[], int columns, int current); +typedef bool (*HPMHOOK_pre_mercenary_read_skill_db_sub) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_mercenary_read_skill_db_sub) (bool retVal___, char *str[], int columns, int current); +#endif // MAP_MERCENARY_H +#ifdef MAP_MOB_H /* mob */ +typedef int (*HPMHOOK_pre_mob_init) (bool *mimimal); +typedef int (*HPMHOOK_post_mob_init) (int retVal___, bool mimimal); +typedef int (*HPMHOOK_pre_mob_final) (void); +typedef int (*HPMHOOK_post_mob_final) (int retVal___); +typedef void (*HPMHOOK_pre_mob_reload) (void); +typedef void (*HPMHOOK_post_mob_reload) (void); +typedef struct mob_db* (*HPMHOOK_pre_mob_db) (int *index); +typedef struct mob_db* (*HPMHOOK_post_mob_db) (struct mob_db* retVal___, int index); +typedef struct mob_chat* (*HPMHOOK_pre_mob_chat) (short *id); +typedef struct mob_chat* (*HPMHOOK_post_mob_chat) (struct mob_chat* retVal___, short id); +typedef int (*HPMHOOK_pre_mob_makedummymobdb) (int *p1); +typedef int (*HPMHOOK_post_mob_makedummymobdb) (int retVal___, int p1); +typedef int (*HPMHOOK_pre_mob_spawn_guardian_sub) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_spawn_guardian_sub) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_mob_skill_id2skill_idx) (int *class_, uint16 *skill_id); +typedef int (*HPMHOOK_post_mob_skill_id2skill_idx) (int retVal___, int class_, uint16 skill_id); +typedef int (*HPMHOOK_pre_mob_db_searchname) (const char **str); +typedef int (*HPMHOOK_post_mob_db_searchname) (int retVal___, const char *str); +typedef int (*HPMHOOK_pre_mob_db_searchname_array_sub) (struct mob_db **monster, const char **str, int *flag); +typedef int (*HPMHOOK_post_mob_db_searchname_array_sub) (int retVal___, struct mob_db *monster, const char *str, int flag); +typedef void (*HPMHOOK_pre_mob_mvptomb_create) (struct mob_data **md, char **killer, time_t *time); +typedef void (*HPMHOOK_post_mob_mvptomb_create) (struct mob_data *md, char *killer, time_t time); +typedef void (*HPMHOOK_pre_mob_mvptomb_destroy) (struct mob_data **md); +typedef void (*HPMHOOK_post_mob_mvptomb_destroy) (struct mob_data *md); +typedef int (*HPMHOOK_pre_mob_db_searchname_array) (struct mob_db ***data, int *size, const char **str, int *flag); +typedef int (*HPMHOOK_post_mob_db_searchname_array) (int retVal___, struct mob_db **data, int size, const char *str, int flag); +typedef int (*HPMHOOK_pre_mob_db_checkid) (const int *id); +typedef int (*HPMHOOK_post_mob_db_checkid) (int retVal___, const int id); +typedef struct view_data* (*HPMHOOK_pre_mob_get_viewdata) (int *class_); +typedef struct view_data* (*HPMHOOK_post_mob_get_viewdata) (struct view_data* retVal___, int class_); +typedef int (*HPMHOOK_pre_mob_parse_dataset) (struct spawn_data **data); +typedef int (*HPMHOOK_post_mob_parse_dataset) (int retVal___, struct spawn_data *data); +typedef struct mob_data* (*HPMHOOK_pre_mob_spawn_dataset) (struct spawn_data **data); +typedef struct mob_data* (*HPMHOOK_post_mob_spawn_dataset) (struct mob_data* retVal___, struct spawn_data *data); +typedef int (*HPMHOOK_pre_mob_get_random_id) (int *type, int *flag, int *lv); +typedef int (*HPMHOOK_post_mob_get_random_id) (int retVal___, int type, int flag, int lv); +typedef bool (*HPMHOOK_pre_mob_ksprotected) (struct block_list **src, struct block_list **target); +typedef bool (*HPMHOOK_post_mob_ksprotected) (bool retVal___, struct block_list *src, struct block_list *target); +typedef struct mob_data* (*HPMHOOK_pre_mob_once_spawn_sub) (struct block_list **bl, int16 *m, int16 *x, int16 *y, const char **mobname, int *class_, const char **event, unsigned int *size, unsigned int *ai); +typedef struct mob_data* (*HPMHOOK_post_mob_once_spawn_sub) (struct mob_data* retVal___, struct block_list *bl, int16 m, int16 x, int16 y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai); +typedef int (*HPMHOOK_pre_mob_once_spawn) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y, const char **mobname, int *class_, int *amount, const char **event, unsigned int *size, unsigned int *ai); +typedef int (*HPMHOOK_post_mob_once_spawn) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai); +typedef int (*HPMHOOK_pre_mob_once_spawn_area) (struct map_session_data **sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char **mobname, int *class_, int *amount, const char **event, unsigned int *size, unsigned int *ai); +typedef int (*HPMHOOK_post_mob_once_spawn_area) (int retVal___, struct map_session_data *sd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai); +typedef int (*HPMHOOK_pre_mob_spawn_guardian) (const char **mapname, short *x, short *y, const char **mobname, int *class_, const char **event, int *guardian, bool *has_index); +typedef int (*HPMHOOK_post_mob_spawn_guardian) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, int guardian, bool has_index); +typedef int (*HPMHOOK_pre_mob_spawn_bg) (const char **mapname, short *x, short *y, const char **mobname, int *class_, const char **event, unsigned int *bg_id); +typedef int (*HPMHOOK_post_mob_spawn_bg) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, unsigned int bg_id); +typedef int (*HPMHOOK_pre_mob_can_reach) (struct mob_data **md, struct block_list **bl, int *range, int *state); +typedef int (*HPMHOOK_post_mob_can_reach) (int retVal___, struct mob_data *md, struct block_list *bl, int range, int state); +typedef int (*HPMHOOK_pre_mob_linksearch) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_linksearch) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_delayspawn) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_delayspawn) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_mob_setdelayspawn) (struct mob_data **md); +typedef int (*HPMHOOK_post_mob_setdelayspawn) (int retVal___, struct mob_data *md); +typedef int (*HPMHOOK_pre_mob_count_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_count_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_spawn) (struct mob_data **md); +typedef int (*HPMHOOK_post_mob_spawn) (int retVal___, struct mob_data *md); +typedef int (*HPMHOOK_pre_mob_can_changetarget) (const struct mob_data **md, const struct block_list **target, uint32 *mode); +typedef int (*HPMHOOK_post_mob_can_changetarget) (int retVal___, const struct mob_data *md, const struct block_list *target, uint32 mode); +typedef int (*HPMHOOK_pre_mob_target) (struct mob_data **md, struct block_list **bl, int *dist); +typedef int (*HPMHOOK_post_mob_target) (int retVal___, struct mob_data *md, struct block_list *bl, int dist); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_activesearch) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_activesearch) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_changechase) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_changechase) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_bg_ally) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_bg_ally) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_lootsearch) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_lootsearch) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_warpchase_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_warpchase_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_slavemob) (struct mob_data **md, int64 *tick); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_slavemob) (int retVal___, struct mob_data *md, int64 tick); +typedef int (*HPMHOOK_pre_mob_unlocktarget) (struct mob_data **md, int64 *tick); +typedef int (*HPMHOOK_post_mob_unlocktarget) (int retVal___, struct mob_data *md, int64 tick); +typedef int (*HPMHOOK_pre_mob_randomwalk) (struct mob_data **md, int64 *tick); +typedef int (*HPMHOOK_post_mob_randomwalk) (int retVal___, struct mob_data *md, int64 tick); +typedef int (*HPMHOOK_pre_mob_warpchase) (struct mob_data **md, struct block_list **target); +typedef int (*HPMHOOK_post_mob_warpchase) (int retVal___, struct mob_data *md, struct block_list *target); +typedef bool (*HPMHOOK_pre_mob_ai_sub_hard) (struct mob_data **md, int64 *tick); +typedef bool (*HPMHOOK_post_mob_ai_sub_hard) (bool retVal___, struct mob_data *md, int64 tick); +typedef int (*HPMHOOK_pre_mob_ai_sub_hard_timer) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_hard_timer) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_foreachclient) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_mob_ai_sub_foreachclient) (int retVal___, struct map_session_data *sd, va_list ap); +typedef int (*HPMHOOK_pre_mob_ai_sub_lazy) (struct mob_data **md, va_list args); +typedef int (*HPMHOOK_post_mob_ai_sub_lazy) (int retVal___, struct mob_data *md, va_list args); +typedef int (*HPMHOOK_pre_mob_ai_lazy) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_ai_lazy) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_mob_ai_hard) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_ai_hard) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef struct item_drop* (*HPMHOOK_pre_mob_setdropitem) (int *nameid, int *qty, struct item_data **data); +typedef struct item_drop* (*HPMHOOK_post_mob_setdropitem) (struct item_drop* retVal___, int nameid, int qty, struct item_data *data); +typedef struct item_drop* (*HPMHOOK_pre_mob_setlootitem) (struct item **item); +typedef struct item_drop* (*HPMHOOK_post_mob_setlootitem) (struct item_drop* retVal___, struct item *item); +typedef int (*HPMHOOK_pre_mob_delay_item_drop) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_delay_item_drop) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_mob_item_drop) (struct mob_data **md, struct item_drop_list **dlist, struct item_drop **ditem, int *loot, int *drop_rate, unsigned short *flag); +typedef void (*HPMHOOK_post_mob_item_drop) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag); +typedef int (*HPMHOOK_pre_mob_timer_delete) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_timer_delete) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_mob_deleteslave_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_deleteslave_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_deleteslave) (struct mob_data **md); +typedef int (*HPMHOOK_post_mob_deleteslave) (int retVal___, struct mob_data *md); +typedef int (*HPMHOOK_pre_mob_respawn) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_mob_respawn) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_mob_log_damage) (struct mob_data **md, struct block_list **src, int *damage); +typedef void (*HPMHOOK_post_mob_log_damage) (struct mob_data *md, struct block_list *src, int damage); +typedef void (*HPMHOOK_pre_mob_damage) (struct mob_data **md, struct block_list **src, int *damage); +typedef void (*HPMHOOK_post_mob_damage) (struct mob_data *md, struct block_list *src, int damage); +typedef int (*HPMHOOK_pre_mob_dead) (struct mob_data **md, struct block_list **src, int *type); +typedef int (*HPMHOOK_post_mob_dead) (int retVal___, struct mob_data *md, struct block_list *src, int type); +typedef void (*HPMHOOK_pre_mob_revive) (struct mob_data **md, unsigned int *hp); +typedef void (*HPMHOOK_post_mob_revive) (struct mob_data *md, unsigned int hp); +typedef int (*HPMHOOK_pre_mob_guardian_guildchange) (struct mob_data **md); +typedef int (*HPMHOOK_post_mob_guardian_guildchange) (int retVal___, struct mob_data *md); +typedef int (*HPMHOOK_pre_mob_random_class) (int **value, size_t *count); +typedef int (*HPMHOOK_post_mob_random_class) (int retVal___, int *value, size_t count); +typedef int (*HPMHOOK_pre_mob_class_change) (struct mob_data **md, int *class_); +typedef int (*HPMHOOK_post_mob_class_change) (int retVal___, struct mob_data *md, int class_); +typedef void (*HPMHOOK_pre_mob_heal) (struct mob_data **md, unsigned int *heal); +typedef void (*HPMHOOK_post_mob_heal) (struct mob_data *md, unsigned int heal); +typedef int (*HPMHOOK_pre_mob_warpslave_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_warpslave_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_warpslave) (struct block_list **bl, int *range); +typedef int (*HPMHOOK_post_mob_warpslave) (int retVal___, struct block_list *bl, int range); +typedef int (*HPMHOOK_pre_mob_countslave_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_countslave_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_mob_countslave) (struct block_list **bl); +typedef int (*HPMHOOK_post_mob_countslave) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_mob_summonslave) (struct mob_data **md2, int **value, int *amount, uint16 *skill_id); +typedef int (*HPMHOOK_post_mob_summonslave) (int retVal___, struct mob_data *md2, int *value, int amount, uint16 skill_id); +typedef int (*HPMHOOK_pre_mob_getfriendhprate_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_getfriendhprate_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef struct block_list* (*HPMHOOK_pre_mob_getfriendhprate) (struct mob_data **md, int *min_rate, int *max_rate); +typedef struct block_list* (*HPMHOOK_post_mob_getfriendhprate) (struct block_list* retVal___, struct mob_data *md, int min_rate, int max_rate); +typedef struct block_list* (*HPMHOOK_pre_mob_getmasterhpltmaxrate) (struct mob_data **md, int *rate); +typedef struct block_list* (*HPMHOOK_post_mob_getmasterhpltmaxrate) (struct block_list* retVal___, struct mob_data *md, int rate); +typedef int (*HPMHOOK_pre_mob_getfriendstatus_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_mob_getfriendstatus_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef struct mob_data* (*HPMHOOK_pre_mob_getfriendstatus) (struct mob_data **md, int *cond1, int *cond2); +typedef struct mob_data* (*HPMHOOK_post_mob_getfriendstatus) (struct mob_data* retVal___, struct mob_data *md, int cond1, int cond2); +typedef int (*HPMHOOK_pre_mob_skill_use) (struct mob_data **md, int64 *tick, int *event); +typedef int (*HPMHOOK_post_mob_skill_use) (int retVal___, struct mob_data *md, int64 tick, int event); +typedef int (*HPMHOOK_pre_mob_skill_event) (struct mob_data **md, struct block_list **src, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_mob_skill_event) (int retVal___, struct mob_data *md, struct block_list *src, int64 tick, int flag); +typedef int (*HPMHOOK_pre_mob_is_clone) (int *class_); +typedef int (*HPMHOOK_post_mob_is_clone) (int retVal___, int class_); +typedef int (*HPMHOOK_pre_mob_clone_spawn) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y, const char **event, int *master_id, uint32 *mode, int *flag, unsigned int *duration); +typedef int (*HPMHOOK_post_mob_clone_spawn) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, uint32 mode, int flag, unsigned int duration); +typedef int (*HPMHOOK_pre_mob_clone_delete) (struct mob_data **md); +typedef int (*HPMHOOK_post_mob_clone_delete) (int retVal___, struct mob_data *md); +typedef unsigned int (*HPMHOOK_pre_mob_drop_adjust) (int *baserate, int *rate_adjust, unsigned short *rate_min, unsigned short *rate_max); +typedef unsigned int (*HPMHOOK_post_mob_drop_adjust) (unsigned int retVal___, int baserate, int rate_adjust, unsigned short rate_min, unsigned short rate_max); +typedef void (*HPMHOOK_pre_mob_item_dropratio_adjust) (int *nameid, int *mob_id, int **rate_adjust); +typedef void (*HPMHOOK_post_mob_item_dropratio_adjust) (int nameid, int mob_id, int *rate_adjust); +typedef void (*HPMHOOK_pre_mob_readdb) (void); +typedef void (*HPMHOOK_post_mob_readdb) (void); +typedef bool (*HPMHOOK_pre_mob_lookup_const) (const struct config_setting_t **it, const char **name, int **value); +typedef bool (*HPMHOOK_post_mob_lookup_const) (bool retVal___, const struct config_setting_t *it, const char *name, int *value); +typedef bool (*HPMHOOK_pre_mob_get_const) (const struct config_setting_t **it, int **value); +typedef bool (*HPMHOOK_post_mob_get_const) (bool retVal___, const struct config_setting_t *it, int *value); +typedef int (*HPMHOOK_pre_mob_db_validate_entry) (struct mob_db **entry, int *n, const char **source); +typedef int (*HPMHOOK_post_mob_db_validate_entry) (int retVal___, struct mob_db *entry, int n, const char *source); +typedef int (*HPMHOOK_pre_mob_read_libconfig) (const char **filename, bool *ignore_missing); +typedef int (*HPMHOOK_post_mob_read_libconfig) (int retVal___, const char *filename, bool ignore_missing); +typedef void (*HPMHOOK_pre_mob_read_db_additional_fields) (struct mob_db **entry, struct config_setting_t **it, int *n, const char **source); +typedef void (*HPMHOOK_post_mob_read_db_additional_fields) (struct mob_db *entry, struct config_setting_t *it, int n, const char *source); +typedef int (*HPMHOOK_pre_mob_read_db_sub) (struct config_setting_t **mobt, int *id, const char **source); +typedef int (*HPMHOOK_post_mob_read_db_sub) (int retVal___, struct config_setting_t *mobt, int id, const char *source); +typedef void (*HPMHOOK_pre_mob_read_db_drops_sub) (struct mob_db **entry, struct config_setting_t **t); +typedef void (*HPMHOOK_post_mob_read_db_drops_sub) (struct mob_db *entry, struct config_setting_t *t); +typedef void (*HPMHOOK_pre_mob_read_db_mvpdrops_sub) (struct mob_db **entry, struct config_setting_t **t); +typedef void (*HPMHOOK_post_mob_read_db_mvpdrops_sub) (struct mob_db *entry, struct config_setting_t *t); +typedef uint32 (*HPMHOOK_pre_mob_read_db_mode_sub) (struct mob_db **entry, struct config_setting_t **t); +typedef uint32 (*HPMHOOK_post_mob_read_db_mode_sub) (uint32 retVal___, struct mob_db *entry, struct config_setting_t *t); +typedef void (*HPMHOOK_pre_mob_read_db_stats_sub) (struct mob_db **entry, struct config_setting_t **t); +typedef void (*HPMHOOK_post_mob_read_db_stats_sub) (struct mob_db *entry, struct config_setting_t *t); +typedef void (*HPMHOOK_pre_mob_name_constants) (void); +typedef void (*HPMHOOK_post_mob_name_constants) (void); +typedef bool (*HPMHOOK_pre_mob_readdb_mobavail) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_mob_readdb_mobavail) (bool retVal___, char *str[], int columns, int current); +typedef int (*HPMHOOK_pre_mob_read_randommonster) (void); +typedef int (*HPMHOOK_post_mob_read_randommonster) (int retVal___); +typedef bool (*HPMHOOK_pre_mob_parse_row_chatdb) (char ***str, const char **source, int *line, int **last_msg_id); +typedef bool (*HPMHOOK_post_mob_parse_row_chatdb) (bool retVal___, char **str, const char *source, int line, int *last_msg_id); +typedef void (*HPMHOOK_pre_mob_readchatdb) (void); +typedef void (*HPMHOOK_post_mob_readchatdb) (void); +typedef bool (*HPMHOOK_pre_mob_parse_row_mobskilldb) (char ***str, int *columns, int *current); +typedef bool (*HPMHOOK_post_mob_parse_row_mobskilldb) (bool retVal___, char **str, int columns, int current); +typedef void (*HPMHOOK_pre_mob_readskilldb) (void); +typedef void (*HPMHOOK_post_mob_readskilldb) (void); +typedef bool (*HPMHOOK_pre_mob_readdb_race2) (char **fields[], int *columns, int *current); +typedef bool (*HPMHOOK_post_mob_readdb_race2) (bool retVal___, char *fields[], int columns, int current); +typedef bool (*HPMHOOK_pre_mob_readdb_itemratio) (char **str[], int *columns, int *current); +typedef bool (*HPMHOOK_post_mob_readdb_itemratio) (bool retVal___, char *str[], int columns, int current); +typedef void (*HPMHOOK_pre_mob_load) (bool *minimal); +typedef void (*HPMHOOK_post_mob_load) (bool minimal); +typedef void (*HPMHOOK_pre_mob_clear_spawninfo) (void); +typedef void (*HPMHOOK_post_mob_clear_spawninfo) (void); +typedef void (*HPMHOOK_pre_mob_destroy_mob_db) (int *index); +typedef void (*HPMHOOK_post_mob_destroy_mob_db) (int index); +#endif // MAP_MOB_H +#ifdef MAP_NPC_H /* npc_chat */ +typedef int (*HPMHOOK_pre_npc_chat_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_npc_chat_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_npc_chat_finalize) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_chat_finalize) (struct npc_data *nd); +typedef void (*HPMHOOK_pre_npc_chat_def_pattern) (struct npc_data **nd, int *setid, const char **pattern, const char **label); +typedef void (*HPMHOOK_post_npc_chat_def_pattern) (struct npc_data *nd, int setid, const char *pattern, const char *label); +typedef struct pcrematch_entry* (*HPMHOOK_pre_npc_chat_create_pcrematch_entry) (struct pcrematch_set **set); +typedef struct pcrematch_entry* (*HPMHOOK_post_npc_chat_create_pcrematch_entry) (struct pcrematch_entry* retVal___, struct pcrematch_set *set); +typedef void (*HPMHOOK_pre_npc_chat_delete_pcreset) (struct npc_data **nd, int *setid); +typedef void (*HPMHOOK_post_npc_chat_delete_pcreset) (struct npc_data *nd, int setid); +typedef void (*HPMHOOK_pre_npc_chat_deactivate_pcreset) (struct npc_data **nd, int *setid); +typedef void (*HPMHOOK_post_npc_chat_deactivate_pcreset) (struct npc_data *nd, int setid); +typedef void (*HPMHOOK_pre_npc_chat_activate_pcreset) (struct npc_data **nd, int *setid); +typedef void (*HPMHOOK_post_npc_chat_activate_pcreset) (struct npc_data *nd, int setid); +typedef struct pcrematch_set* (*HPMHOOK_pre_npc_chat_lookup_pcreset) (struct npc_data **nd, int *setid); +typedef struct pcrematch_set* (*HPMHOOK_post_npc_chat_lookup_pcreset) (struct pcrematch_set* retVal___, struct npc_data *nd, int setid); +typedef void (*HPMHOOK_pre_npc_chat_finalize_pcrematch_entry) (struct pcrematch_entry **e); +typedef void (*HPMHOOK_post_npc_chat_finalize_pcrematch_entry) (struct pcrematch_entry *e); +#endif // MAP_NPC_H +#ifdef MAP_NPC_H /* npc */ +typedef int (*HPMHOOK_pre_npc_init) (bool *minimal); +typedef int (*HPMHOOK_post_npc_init) (int retVal___, bool minimal); +typedef int (*HPMHOOK_pre_npc_final) (void); +typedef int (*HPMHOOK_post_npc_final) (int retVal___); +typedef int (*HPMHOOK_pre_npc_get_new_npc_id) (void); +typedef int (*HPMHOOK_post_npc_get_new_npc_id) (int retVal___); +typedef struct view_data* (*HPMHOOK_pre_npc_get_viewdata) (int *class_); +typedef struct view_data* (*HPMHOOK_post_npc_get_viewdata) (struct view_data* retVal___, int class_); +typedef int (*HPMHOOK_pre_npc_isnear_sub) (struct block_list **bl, va_list args); +typedef int (*HPMHOOK_post_npc_isnear_sub) (int retVal___, struct block_list *bl, va_list args); +typedef bool (*HPMHOOK_pre_npc_isnear) (struct block_list **bl); +typedef bool (*HPMHOOK_post_npc_isnear) (bool retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_npc_ontouch_event) (struct map_session_data **sd, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_ontouch_event) (int retVal___, struct map_session_data *sd, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_ontouch2_event) (struct map_session_data **sd, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_ontouch2_event) (int retVal___, struct map_session_data *sd, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_onuntouch_event) (struct map_session_data **sd, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_onuntouch_event) (int retVal___, struct map_session_data *sd, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_enable_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_npc_enable_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_npc_enable) (const char **name, int *flag); +typedef int (*HPMHOOK_post_npc_enable) (int retVal___, const char *name, int flag); +typedef struct npc_data* (*HPMHOOK_pre_npc_name2id) (const char **name); +typedef struct npc_data* (*HPMHOOK_post_npc_name2id) (struct npc_data* retVal___, const char *name); +typedef int (*HPMHOOK_pre_npc_event_dequeue) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_npc_event_dequeue) (int retVal___, struct map_session_data *sd); +typedef struct DBData (*HPMHOOK_pre_npc_event_export_create) (union DBKey *key, va_list args); +typedef struct DBData (*HPMHOOK_post_npc_event_export_create) (struct DBData retVal___, union DBKey key, va_list args); +typedef int (*HPMHOOK_pre_npc_event_export) (struct npc_data **nd, int *i); +typedef int (*HPMHOOK_post_npc_event_export) (int retVal___, struct npc_data *nd, int i); +typedef int (*HPMHOOK_pre_npc_event_sub) (struct map_session_data **sd, struct event_data **ev, const char **eventname); +typedef int (*HPMHOOK_post_npc_event_sub) (int retVal___, struct map_session_data *sd, struct event_data *ev, const char *eventname); +typedef void (*HPMHOOK_pre_npc_event_doall_sub) (void **key, void **data, va_list ap); +typedef void (*HPMHOOK_post_npc_event_doall_sub) (void *key, void *data, va_list ap); +typedef int (*HPMHOOK_pre_npc_event_do) (const char **name); +typedef int (*HPMHOOK_post_npc_event_do) (int retVal___, const char *name); +typedef int (*HPMHOOK_pre_npc_event_doall_id) (const char **name, int *rid); +typedef int (*HPMHOOK_post_npc_event_doall_id) (int retVal___, const char *name, int rid); +typedef int (*HPMHOOK_pre_npc_event_doall) (const char **name); +typedef int (*HPMHOOK_post_npc_event_doall) (int retVal___, const char *name); +typedef int (*HPMHOOK_pre_npc_event_do_clock) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_npc_event_do_clock) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_npc_event_do_oninit) (bool *reload); +typedef void (*HPMHOOK_post_npc_event_do_oninit) (bool reload); +typedef int (*HPMHOOK_pre_npc_timerevent_export) (struct npc_data **nd, int *i); +typedef int (*HPMHOOK_post_npc_timerevent_export) (int retVal___, struct npc_data *nd, int i); +typedef int (*HPMHOOK_pre_npc_timerevent) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_npc_timerevent) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_npc_timerevent_start) (struct npc_data **nd, int *rid); +typedef int (*HPMHOOK_post_npc_timerevent_start) (int retVal___, struct npc_data *nd, int rid); +typedef int (*HPMHOOK_pre_npc_timerevent_stop) (struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_timerevent_stop) (int retVal___, struct npc_data *nd); +typedef void (*HPMHOOK_pre_npc_timerevent_quit) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_npc_timerevent_quit) (struct map_session_data *sd); +typedef int64 (*HPMHOOK_pre_npc_gettimerevent_tick) (struct npc_data **nd); +typedef int64 (*HPMHOOK_post_npc_gettimerevent_tick) (int64 retVal___, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_settimerevent_tick) (struct npc_data **nd, int *newtimer); +typedef int (*HPMHOOK_post_npc_settimerevent_tick) (int retVal___, struct npc_data *nd, int newtimer); +typedef int (*HPMHOOK_pre_npc_event) (struct map_session_data **sd, const char **eventname, int *ontouch); +typedef int (*HPMHOOK_post_npc_event) (int retVal___, struct map_session_data *sd, const char *eventname, int ontouch); +typedef int (*HPMHOOK_pre_npc_touch_areanpc_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_npc_touch_areanpc_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_npc_touchnext_areanpc) (struct map_session_data **sd, bool *leavemap); +typedef int (*HPMHOOK_post_npc_touchnext_areanpc) (int retVal___, struct map_session_data *sd, bool leavemap); +typedef int (*HPMHOOK_pre_npc_touch_areanpc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y); +typedef int (*HPMHOOK_post_npc_touch_areanpc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y); +typedef int (*HPMHOOK_pre_npc_untouch_areanpc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y); +typedef int (*HPMHOOK_post_npc_untouch_areanpc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y); +typedef int (*HPMHOOK_pre_npc_touch_areanpc2) (struct mob_data **md); +typedef int (*HPMHOOK_post_npc_touch_areanpc2) (int retVal___, struct mob_data *md); +typedef int (*HPMHOOK_pre_npc_check_areanpc) (int *flag, int16 *m, int16 *x, int16 *y, int16 *range); +typedef int (*HPMHOOK_post_npc_check_areanpc) (int retVal___, int flag, int16 m, int16 x, int16 y, int16 range); +typedef struct npc_data* (*HPMHOOK_pre_npc_checknear) (struct map_session_data **sd, struct block_list **bl); +typedef struct npc_data* (*HPMHOOK_post_npc_checknear) (struct npc_data* retVal___, struct map_session_data *sd, struct block_list *bl); +typedef int (*HPMHOOK_pre_npc_globalmessage) (const char **name, const char **mes); +typedef int (*HPMHOOK_post_npc_globalmessage) (int retVal___, const char *name, const char *mes); +typedef void (*HPMHOOK_pre_npc_run_tomb) (struct map_session_data **sd, struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_run_tomb) (struct map_session_data *sd, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_click) (struct map_session_data **sd, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_click) (int retVal___, struct map_session_data *sd, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_scriptcont) (struct map_session_data **sd, int *id, bool *closing); +typedef int (*HPMHOOK_post_npc_scriptcont) (int retVal___, struct map_session_data *sd, int id, bool closing); +typedef int (*HPMHOOK_pre_npc_buysellsel) (struct map_session_data **sd, int *id, int *type); +typedef int (*HPMHOOK_post_npc_buysellsel) (int retVal___, struct map_session_data *sd, int id, int type); +typedef int (*HPMHOOK_pre_npc_cashshop_buylist) (struct map_session_data **sd, int *points, struct itemlist **item_list); +typedef int (*HPMHOOK_post_npc_cashshop_buylist) (int retVal___, struct map_session_data *sd, int points, struct itemlist *item_list); +typedef int (*HPMHOOK_pre_npc_buylist_sub) (struct map_session_data **sd, struct itemlist **item_list, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_buylist_sub) (int retVal___, struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_cashshop_buy) (struct map_session_data **sd, int *nameid, int *amount, int *points); +typedef int (*HPMHOOK_post_npc_cashshop_buy) (int retVal___, struct map_session_data *sd, int nameid, int amount, int points); +typedef int (*HPMHOOK_pre_npc_buylist) (struct map_session_data **sd, struct itemlist **item_list); +typedef int (*HPMHOOK_post_npc_buylist) (int retVal___, struct map_session_data *sd, struct itemlist *item_list); +typedef int (*HPMHOOK_pre_npc_selllist_sub) (struct map_session_data **sd, struct itemlist **item_list, struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_selllist_sub) (int retVal___, struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_selllist) (struct map_session_data **sd, struct itemlist **item_list); +typedef int (*HPMHOOK_post_npc_selllist) (int retVal___, struct map_session_data *sd, struct itemlist *item_list); +typedef int (*HPMHOOK_pre_npc_remove_map) (struct npc_data **nd); +typedef int (*HPMHOOK_post_npc_remove_map) (int retVal___, struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_unload_ev) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_npc_unload_ev) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_npc_unload_ev_label) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_npc_unload_ev_label) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_npc_unload_dup_sub) (struct npc_data **nd, va_list args); +typedef int (*HPMHOOK_post_npc_unload_dup_sub) (int retVal___, struct npc_data *nd, va_list args); +typedef void (*HPMHOOK_pre_npc_unload_duplicates) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_unload_duplicates) (struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_unload) (struct npc_data **nd, bool *single); +typedef int (*HPMHOOK_post_npc_unload) (int retVal___, struct npc_data *nd, bool single); +typedef void (*HPMHOOK_pre_npc_clearsrcfile) (void); +typedef void (*HPMHOOK_post_npc_clearsrcfile) (void); +typedef void (*HPMHOOK_pre_npc_addsrcfile) (const char **name); +typedef void (*HPMHOOK_post_npc_addsrcfile) (const char *name); +typedef void (*HPMHOOK_pre_npc_delsrcfile) (const char **name); +typedef void (*HPMHOOK_post_npc_delsrcfile) (const char *name); +typedef const char* (*HPMHOOK_pre_npc_retainpathreference) (const char **filepath); +typedef const char* (*HPMHOOK_post_npc_retainpathreference) (const char* retVal___, const char *filepath); +typedef void (*HPMHOOK_pre_npc_releasepathreference) (const char **filepath); +typedef void (*HPMHOOK_post_npc_releasepathreference) (const char *filepath); +typedef void (*HPMHOOK_pre_npc_parsename) (struct npc_data **nd, const char **name, const char **start, const char **buffer, const char **filepath); +typedef void (*HPMHOOK_post_npc_parsename) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath); +typedef int (*HPMHOOK_pre_npc_parseview) (const char **w4, const char **start, const char **buffer, const char **filepath); +typedef int (*HPMHOOK_post_npc_parseview) (int retVal___, const char *w4, const char *start, const char *buffer, const char *filepath); +typedef bool (*HPMHOOK_pre_npc_viewisid) (const char **viewid); +typedef bool (*HPMHOOK_post_npc_viewisid) (bool retVal___, const char *viewid); +typedef struct npc_data* (*HPMHOOK_pre_npc_create_npc) (enum npc_subtype *subtype, int *m, int *x, int *y, uint8 *dir, int16 *class_); +typedef struct npc_data* (*HPMHOOK_post_npc_create_npc) (struct npc_data* retVal___, enum npc_subtype subtype, int m, int x, int y, uint8 dir, int16 class_); +typedef struct npc_data* (*HPMHOOK_pre_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); +typedef struct npc_data* (*HPMHOOK_post_npc_add_warp) (struct npc_data* retVal___, 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); +typedef const char* (*HPMHOOK_pre_npc_parse_warp) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_warp) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef const char* (*HPMHOOK_pre_npc_parse_shop) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_shop) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef const char* (*HPMHOOK_pre_npc_parse_unknown_object) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_unknown_object) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef void (*HPMHOOK_pre_npc_convertlabel_db) (struct npc_label_list **label_list, const char **filepath); +typedef void (*HPMHOOK_post_npc_convertlabel_db) (struct npc_label_list *label_list, const char *filepath); +typedef const char* (*HPMHOOK_pre_npc_skip_script) (const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_skip_script) (const char* retVal___, const char *start, const char *buffer, const char *filepath, int *retval); +typedef const char* (*HPMHOOK_pre_npc_parse_script) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_script) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval); +typedef void (*HPMHOOK_pre_npc_add_to_location) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_add_to_location) (struct npc_data *nd); +typedef bool (*HPMHOOK_pre_npc_duplicate_script_sub) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); +typedef bool (*HPMHOOK_post_npc_duplicate_script_sub) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); +typedef bool (*HPMHOOK_pre_npc_duplicate_shop_sub) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); +typedef bool (*HPMHOOK_post_npc_duplicate_shop_sub) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); +typedef bool (*HPMHOOK_pre_npc_duplicate_warp_sub) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); +typedef bool (*HPMHOOK_post_npc_duplicate_warp_sub) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); +typedef bool (*HPMHOOK_pre_npc_duplicate_sub) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); +typedef bool (*HPMHOOK_post_npc_duplicate_sub) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); +typedef const char* (*HPMHOOK_pre_npc_parse_duplicate) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_duplicate) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval); +typedef int (*HPMHOOK_pre_npc_duplicate4instance) (struct npc_data **snd, int16 *m); +typedef int (*HPMHOOK_post_npc_duplicate4instance) (int retVal___, struct npc_data *snd, int16 m); +typedef void (*HPMHOOK_pre_npc_setcells) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_setcells) (struct npc_data *nd); +typedef int (*HPMHOOK_pre_npc_unsetcells_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_npc_unsetcells_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_npc_unsetcells) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_unsetcells) (struct npc_data *nd); +typedef void (*HPMHOOK_pre_npc_movenpc) (struct npc_data **nd, int16 *x, int16 *y); +typedef void (*HPMHOOK_post_npc_movenpc) (struct npc_data *nd, int16 x, int16 y); +typedef void (*HPMHOOK_pre_npc_setdisplayname) (struct npc_data **nd, const char **newname); +typedef void (*HPMHOOK_post_npc_setdisplayname) (struct npc_data *nd, const char *newname); +typedef void (*HPMHOOK_pre_npc_setclass) (struct npc_data **nd, short *class_); +typedef void (*HPMHOOK_post_npc_setclass) (struct npc_data *nd, short class_); +typedef int (*HPMHOOK_pre_npc_do_atcmd_event) (struct map_session_data **sd, const char **command, const char **message, const char **eventname); +typedef int (*HPMHOOK_post_npc_do_atcmd_event) (int retVal___, struct map_session_data *sd, const char *command, const char *message, const char *eventname); +typedef const char* (*HPMHOOK_pre_npc_parse_function) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_function) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef void (*HPMHOOK_pre_npc_parse_mob2) (struct spawn_data **mobspawn); +typedef void (*HPMHOOK_post_npc_parse_mob2) (struct spawn_data *mobspawn); +typedef const char* (*HPMHOOK_pre_npc_parse_mob) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_mob) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef const char* (*HPMHOOK_pre_npc_parse_mapflag) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef const char* (*HPMHOOK_post_npc_parse_mapflag) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef void (*HPMHOOK_pre_npc_parse_unknown_mapflag) (const char **name, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); +typedef void (*HPMHOOK_post_npc_parse_unknown_mapflag) (const char *name, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); +typedef int (*HPMHOOK_pre_npc_parsesrcfile) (const char **filepath, bool *runOnInit); +typedef int (*HPMHOOK_post_npc_parsesrcfile) (int retVal___, const char *filepath, bool runOnInit); +typedef int (*HPMHOOK_pre_npc_script_event) (struct map_session_data **sd, enum npce_event *type); +typedef int (*HPMHOOK_post_npc_script_event) (int retVal___, struct map_session_data *sd, enum npce_event type); +typedef void (*HPMHOOK_pre_npc_read_event_script) (void); +typedef void (*HPMHOOK_post_npc_read_event_script) (void); +typedef int (*HPMHOOK_pre_npc_path_db_clear_sub) (union DBKey *key, struct DBData **data, va_list args); +typedef int (*HPMHOOK_post_npc_path_db_clear_sub) (int retVal___, union DBKey key, struct DBData *data, va_list args); +typedef int (*HPMHOOK_pre_npc_ev_label_db_clear_sub) (union DBKey *key, struct DBData **data, va_list args); +typedef int (*HPMHOOK_post_npc_ev_label_db_clear_sub) (int retVal___, union DBKey key, struct DBData *data, va_list args); +typedef int (*HPMHOOK_pre_npc_reload) (void); +typedef int (*HPMHOOK_post_npc_reload) (int retVal___); +typedef bool (*HPMHOOK_pre_npc_unloadfile) (const char **filepath); +typedef bool (*HPMHOOK_post_npc_unloadfile) (bool retVal___, const char *filepath); +typedef void (*HPMHOOK_pre_npc_do_clear_npc) (void); +typedef void (*HPMHOOK_post_npc_do_clear_npc) (void); +typedef void (*HPMHOOK_pre_npc_debug_warps_sub) (struct npc_data **nd); +typedef void (*HPMHOOK_post_npc_debug_warps_sub) (struct npc_data *nd); +typedef void (*HPMHOOK_pre_npc_debug_warps) (void); +typedef void (*HPMHOOK_post_npc_debug_warps) (void); +typedef void (*HPMHOOK_pre_npc_trader_count_funds) (struct npc_data **nd, struct map_session_data **sd); +typedef void (*HPMHOOK_post_npc_trader_count_funds) (struct npc_data *nd, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_npc_trader_pay) (struct npc_data **nd, struct map_session_data **sd, int *price, int *points); +typedef bool (*HPMHOOK_post_npc_trader_pay) (bool retVal___, struct npc_data *nd, struct map_session_data *sd, int price, int points); +typedef void (*HPMHOOK_pre_npc_trader_update) (int *master); +typedef void (*HPMHOOK_post_npc_trader_update) (int master); +typedef int (*HPMHOOK_pre_npc_market_buylist) (struct map_session_data **sd, struct itemlist **item_list); +typedef int (*HPMHOOK_post_npc_market_buylist) (int retVal___, struct map_session_data *sd, struct itemlist *item_list); +typedef bool (*HPMHOOK_pre_npc_trader_open) (struct map_session_data **sd, struct npc_data **nd); +typedef bool (*HPMHOOK_post_npc_trader_open) (bool retVal___, struct map_session_data *sd, struct npc_data *nd); +typedef void (*HPMHOOK_pre_npc_market_fromsql) (void); +typedef void (*HPMHOOK_post_npc_market_fromsql) (void); +typedef void (*HPMHOOK_pre_npc_market_tosql) (struct npc_data **nd, unsigned short *index); +typedef void (*HPMHOOK_post_npc_market_tosql) (struct npc_data *nd, unsigned short index); +typedef void (*HPMHOOK_pre_npc_market_delfromsql) (struct npc_data **nd, unsigned short *index); +typedef void (*HPMHOOK_post_npc_market_delfromsql) (struct npc_data *nd, unsigned short index); +typedef void (*HPMHOOK_pre_npc_market_delfromsql_sub) (const char **npcname, unsigned short *index); +typedef void (*HPMHOOK_post_npc_market_delfromsql_sub) (const char *npcname, unsigned short index); +typedef bool (*HPMHOOK_pre_npc_db_checkid) (const int *id); +typedef bool (*HPMHOOK_post_npc_db_checkid) (bool retVal___, const int id); +typedef int (*HPMHOOK_pre_npc_secure_timeout_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_npc_secure_timeout_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +#endif // MAP_NPC_H +#ifdef COMMON_NULLPO_H /* nullpo */ +typedef void (*HPMHOOK_pre_nullpo_assert_report) (const char **file, int *line, const char **func, const char **targetname, const char **title); +typedef void (*HPMHOOK_post_nullpo_assert_report) (const char *file, int line, const char *func, const char *targetname, const char *title); +#endif // COMMON_NULLPO_H +#ifdef MAP_PARTY_H /* party */ +typedef void (*HPMHOOK_pre_party_init) (bool *minimal); +typedef void (*HPMHOOK_post_party_init) (bool minimal); +typedef void (*HPMHOOK_pre_party_final) (void); +typedef void (*HPMHOOK_post_party_final) (void); +typedef struct party_data* (*HPMHOOK_pre_party_search) (int *party_id); +typedef struct party_data* (*HPMHOOK_post_party_search) (struct party_data* retVal___, int party_id); +typedef struct party_data* (*HPMHOOK_pre_party_searchname) (const char **str); +typedef struct party_data* (*HPMHOOK_post_party_searchname) (struct party_data* retVal___, const char *str); +typedef int (*HPMHOOK_pre_party_getmemberid) (struct party_data **p, struct map_session_data **sd); +typedef int (*HPMHOOK_post_party_getmemberid) (int retVal___, struct party_data *p, struct map_session_data *sd); +typedef struct map_session_data* (*HPMHOOK_pre_party_getavailablesd) (struct party_data **p); +typedef struct map_session_data* (*HPMHOOK_post_party_getavailablesd) (struct map_session_data* retVal___, struct party_data *p); +typedef int (*HPMHOOK_pre_party_create) (struct map_session_data **sd, const char **name, int *item, int *item2); +typedef int (*HPMHOOK_post_party_create) (int retVal___, struct map_session_data *sd, const char *name, int item, int item2); +typedef void (*HPMHOOK_pre_party_created) (int *account_id, int *char_id, int *fail, int *party_id, const char **name); +typedef void (*HPMHOOK_post_party_created) (int account_id, int char_id, int fail, int party_id, const char *name); +typedef int (*HPMHOOK_pre_party_request_info) (int *party_id, int *char_id); +typedef int (*HPMHOOK_post_party_request_info) (int retVal___, int party_id, int char_id); +typedef int (*HPMHOOK_pre_party_invite) (struct map_session_data **sd, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_party_invite) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_party_member_joined) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_party_member_joined) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_member_added) (int *party_id, int *account_id, int *char_id, int *flag); +typedef int (*HPMHOOK_post_party_member_added) (int retVal___, int party_id, int account_id, int char_id, int flag); +typedef int (*HPMHOOK_pre_party_leave) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_party_leave) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_removemember) (struct map_session_data **sd, int *account_id, const char **name); +typedef int (*HPMHOOK_post_party_removemember) (int retVal___, struct map_session_data *sd, int account_id, const char *name); +typedef int (*HPMHOOK_pre_party_member_withdraw) (int *party_id, int *account_id, int *char_id); +typedef int (*HPMHOOK_post_party_member_withdraw) (int retVal___, int party_id, int account_id, int char_id); +typedef void (*HPMHOOK_pre_party_reply_invite) (struct map_session_data **sd, int *party_id, int *flag); +typedef void (*HPMHOOK_post_party_reply_invite) (struct map_session_data *sd, int party_id, int flag); +typedef int (*HPMHOOK_pre_party_recv_noinfo) (int *party_id, int *char_id); +typedef int (*HPMHOOK_post_party_recv_noinfo) (int retVal___, int party_id, int char_id); +typedef int (*HPMHOOK_pre_party_recv_info) (const struct party **sp, int *char_id); +typedef int (*HPMHOOK_post_party_recv_info) (int retVal___, const struct party *sp, int char_id); +typedef int (*HPMHOOK_pre_party_recv_movemap) (int *party_id, int *account_id, int *char_id, unsigned short *mapid, int *online, int *lv); +typedef int (*HPMHOOK_post_party_recv_movemap) (int retVal___, int party_id, int account_id, int char_id, unsigned short mapid, int online, int lv); +typedef int (*HPMHOOK_pre_party_broken) (int *party_id); +typedef int (*HPMHOOK_post_party_broken) (int retVal___, int party_id); +typedef int (*HPMHOOK_pre_party_optionchanged) (int *party_id, int *account_id, int *exp, int *item, int *flag); +typedef int (*HPMHOOK_post_party_optionchanged) (int retVal___, int party_id, int account_id, int exp, int item, int flag); +typedef int (*HPMHOOK_pre_party_changeoption) (struct map_session_data **sd, int *exp, int *item); +typedef int (*HPMHOOK_post_party_changeoption) (int retVal___, struct map_session_data *sd, int exp, int item); +typedef bool (*HPMHOOK_pre_party_changeleader) (struct map_session_data **sd, struct map_session_data **t_sd); +typedef bool (*HPMHOOK_post_party_changeleader) (bool retVal___, struct map_session_data *sd, struct map_session_data *t_sd); +typedef void (*HPMHOOK_pre_party_send_movemap) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_party_send_movemap) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_party_send_levelup) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_party_send_levelup) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_send_logout) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_party_send_logout) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_send_message) (struct map_session_data **sd, const char **mes); +typedef int (*HPMHOOK_post_party_send_message) (int retVal___, struct map_session_data *sd, const char *mes); +typedef int (*HPMHOOK_pre_party_recv_message) (int *party_id, int *account_id, const char **mes, int *len); +typedef int (*HPMHOOK_post_party_recv_message) (int retVal___, int party_id, int account_id, const char *mes, int len); +typedef int (*HPMHOOK_pre_party_skill_check) (struct map_session_data **sd, int *party_id, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_party_skill_check) (int retVal___, struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_party_send_xy_clear) (struct party_data **p); +typedef int (*HPMHOOK_post_party_send_xy_clear) (int retVal___, struct party_data *p); +typedef int (*HPMHOOK_pre_party_exp_share) (struct party_data **p, struct block_list **src, unsigned int *base_exp, unsigned int *job_exp, int *zeny); +typedef int (*HPMHOOK_post_party_exp_share) (int retVal___, struct party_data *p, struct block_list *src, unsigned int base_exp, unsigned int job_exp, int zeny); +typedef int (*HPMHOOK_pre_party_share_loot) (struct party_data **p, struct map_session_data **sd, struct item **item_data, int *first_charid); +typedef int (*HPMHOOK_post_party_share_loot) (int retVal___, struct party_data *p, struct map_session_data *sd, struct item *item_data, int first_charid); +typedef int (*HPMHOOK_pre_party_send_dot_remove) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_party_send_dot_remove) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_sub_count) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_party_sub_count) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_party_sub_count_chorus) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_party_sub_count_chorus) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_party_booking_register) (struct map_session_data **sd, short *level, short *mapid, short **job); +typedef void (*HPMHOOK_post_party_booking_register) (struct map_session_data *sd, short level, short mapid, short *job); +typedef void (*HPMHOOK_pre_party_booking_update) (struct map_session_data **sd, short **job); +typedef void (*HPMHOOK_post_party_booking_update) (struct map_session_data *sd, short *job); +typedef void (*HPMHOOK_pre_party_booking_search) (struct map_session_data **sd, short *level, short *mapid, short *job, unsigned long *lastindex, short *resultcount); +typedef void (*HPMHOOK_post_party_booking_search) (struct map_session_data *sd, short level, short mapid, short job, unsigned long lastindex, short resultcount); +typedef void (*HPMHOOK_pre_party_recruit_register) (struct map_session_data **sd, short *level, const char **notice); +typedef void (*HPMHOOK_post_party_recruit_register) (struct map_session_data *sd, short level, const char *notice); +typedef void (*HPMHOOK_pre_party_recruit_update) (struct map_session_data **sd, const char **notice); +typedef void (*HPMHOOK_post_party_recruit_update) (struct map_session_data *sd, const char *notice); +typedef void (*HPMHOOK_pre_party_recruit_search) (struct map_session_data **sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount); +typedef void (*HPMHOOK_post_party_recruit_search) (struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount); +typedef bool (*HPMHOOK_pre_party_booking_delete) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_party_booking_delete) (bool retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_party_vforeachsamemap) (int ( **func ) (struct block_list *, va_list), struct map_session_data **sd, int *range, va_list ap); +typedef int (*HPMHOOK_post_party_vforeachsamemap) (int retVal___, int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int range, va_list ap); +typedef int (*HPMHOOK_pre_party_send_xy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_party_send_xy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_party_fill_member) (struct party_member **member, struct map_session_data **sd, unsigned int *leader); +typedef void (*HPMHOOK_post_party_fill_member) (struct party_member *member, struct map_session_data *sd, unsigned int leader); +typedef struct map_session_data* (*HPMHOOK_pre_party_sd_check) (int *party_id, int *account_id, int *char_id); +typedef struct map_session_data* (*HPMHOOK_post_party_sd_check) (struct map_session_data* retVal___, int party_id, int account_id, int char_id); +typedef void (*HPMHOOK_pre_party_check_state) (struct party_data **p); +typedef void (*HPMHOOK_post_party_check_state) (struct party_data *p); +typedef struct party_booking_ad_info* (*HPMHOOK_pre_party_create_booking_data) (void); +typedef struct party_booking_ad_info* (*HPMHOOK_post_party_create_booking_data) (struct party_booking_ad_info* retVal___); +typedef int (*HPMHOOK_pre_party_db_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_party_db_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +#endif // MAP_PARTY_H +#ifdef MAP_PATH_H /* path */ +typedef int (*HPMHOOK_pre_path_blownpos) (struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count); +typedef int (*HPMHOOK_post_path_blownpos) (int retVal___, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count); +typedef bool (*HPMHOOK_pre_path_search) (struct walkpath_data **wpd, struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell); +typedef bool (*HPMHOOK_post_path_search) (bool retVal___, struct walkpath_data *wpd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell); +typedef bool (*HPMHOOK_pre_path_search_long) (struct shootpath_data **spd, struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell); +typedef bool (*HPMHOOK_post_path_search_long) (bool retVal___, struct shootpath_data *spd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, cell_chk cell); +typedef bool (*HPMHOOK_pre_path_check_distance) (int *dx, int *dy, int *distance); +typedef bool (*HPMHOOK_post_path_check_distance) (bool retVal___, int dx, int dy, int distance); +typedef unsigned int (*HPMHOOK_pre_path_distance) (int *dx, int *dy); +typedef unsigned int (*HPMHOOK_post_path_distance) (unsigned int retVal___, int dx, int dy); +typedef bool (*HPMHOOK_pre_path_check_distance_client) (int *dx, int *dy, int *distance); +typedef bool (*HPMHOOK_post_path_check_distance_client) (bool retVal___, int dx, int dy, int distance); +typedef int (*HPMHOOK_pre_path_distance_client) (int *dx, int *dy); +typedef int (*HPMHOOK_post_path_distance_client) (int retVal___, int dx, int dy); +#endif // MAP_PATH_H +#ifdef MAP_PC_GROUPS_H /* pcg */ +typedef void (*HPMHOOK_pre_pcg_init) (void); +typedef void (*HPMHOOK_post_pcg_init) (void); +typedef void (*HPMHOOK_pre_pcg_final) (void); +typedef void (*HPMHOOK_post_pcg_final) (void); +typedef void (*HPMHOOK_pre_pcg_reload) (void); +typedef void (*HPMHOOK_post_pcg_reload) (void); +typedef GroupSettings* (*HPMHOOK_pre_pcg_get_dummy_group) (void); +typedef GroupSettings* (*HPMHOOK_post_pcg_get_dummy_group) (GroupSettings* retVal___); +typedef bool (*HPMHOOK_pre_pcg_exists) (int *group_id); +typedef bool (*HPMHOOK_post_pcg_exists) (bool retVal___, int group_id); +typedef GroupSettings* (*HPMHOOK_pre_pcg_id2group) (int *group_id); +typedef GroupSettings* (*HPMHOOK_post_pcg_id2group) (GroupSettings* retVal___, int group_id); +typedef bool (*HPMHOOK_pre_pcg_has_permission) (GroupSettings **group, unsigned int *permission); +typedef bool (*HPMHOOK_post_pcg_has_permission) (bool retVal___, GroupSettings *group, unsigned int permission); +typedef bool (*HPMHOOK_pre_pcg_should_log_commands) (GroupSettings **group); +typedef bool (*HPMHOOK_post_pcg_should_log_commands) (bool retVal___, GroupSettings *group); +typedef const char* (*HPMHOOK_pre_pcg_get_name) (GroupSettings **group); +typedef const char* (*HPMHOOK_post_pcg_get_name) (const char* retVal___, GroupSettings *group); +typedef int (*HPMHOOK_pre_pcg_get_level) (GroupSettings **group); +typedef int (*HPMHOOK_post_pcg_get_level) (int retVal___, GroupSettings *group); +typedef int (*HPMHOOK_pre_pcg_get_idx) (GroupSettings **group); +typedef int (*HPMHOOK_post_pcg_get_idx) (int retVal___, GroupSettings *group); +#endif // MAP_PC_GROUPS_H +#ifdef MAP_PC_H /* pc */ +typedef void (*HPMHOOK_pre_pc_init) (bool *minimal); +typedef void (*HPMHOOK_post_pc_init) (bool minimal); +typedef void (*HPMHOOK_pre_pc_final) (void); +typedef void (*HPMHOOK_post_pc_final) (void); +typedef struct map_session_data* (*HPMHOOK_pre_pc_get_dummy_sd) (void); +typedef struct map_session_data* (*HPMHOOK_post_pc_get_dummy_sd) (struct map_session_data* retVal___); +typedef int (*HPMHOOK_pre_pc_class2idx) (int *class_); +typedef int (*HPMHOOK_post_pc_class2idx) (int retVal___, int class_); +typedef bool (*HPMHOOK_pre_pc_can_talk) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_pc_can_talk) (bool retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_pc_can_attack) (struct map_session_data **sd, int *target_id); +typedef bool (*HPMHOOK_post_pc_can_attack) (bool retVal___, struct map_session_data *sd, int target_id); +typedef bool (*HPMHOOK_pre_pc_can_use_command) (struct map_session_data **sd, const char **command); +typedef bool (*HPMHOOK_post_pc_can_use_command) (bool retVal___, struct map_session_data *sd, const char *command); +typedef int (*HPMHOOK_pre_pc_set_group) (struct map_session_data **sd, int *group_id); +typedef int (*HPMHOOK_post_pc_set_group) (int retVal___, struct map_session_data *sd, int group_id); +typedef bool (*HPMHOOK_pre_pc_should_log_commands) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_pc_should_log_commands) (bool retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_setrestartvalue) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_setrestartvalue) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pc_makesavestatus) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_makesavestatus) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_respawn) (struct map_session_data **sd, clr_type *clrtype); +typedef void (*HPMHOOK_post_pc_respawn) (struct map_session_data *sd, clr_type clrtype); +typedef int (*HPMHOOK_pre_pc_setnewpc) (struct map_session_data **sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd); +typedef int (*HPMHOOK_post_pc_setnewpc) (int retVal___, struct map_session_data *sd, int account_id, int char_id, int login_id1, unsigned int client_tick, int sex, int fd); +typedef bool (*HPMHOOK_pre_pc_authok) (struct map_session_data **sd, int *login_id2, time_t *expiration_time, int *group_id, const struct mmo_charstatus **st, bool *changing_mapservers); +typedef bool (*HPMHOOK_post_pc_authok) (bool retVal___, struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, const struct mmo_charstatus *st, bool changing_mapservers); +typedef void (*HPMHOOK_pre_pc_authfail) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_authfail) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_reg_received) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_reg_received) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_isequip) (struct map_session_data **sd, int *n); +typedef int (*HPMHOOK_post_pc_isequip) (int retVal___, struct map_session_data *sd, int n); +typedef int (*HPMHOOK_pre_pc_equippoint) (struct map_session_data **sd, int *n); +typedef int (*HPMHOOK_post_pc_equippoint) (int retVal___, struct map_session_data *sd, int n); +typedef int (*HPMHOOK_pre_pc_setinventorydata) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_setinventorydata) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_checkskill) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_pc_checkskill) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_pc_checkskill2) (struct map_session_data **sd, uint16 *index); +typedef int (*HPMHOOK_post_pc_checkskill2) (int retVal___, struct map_session_data *sd, uint16 index); +typedef int (*HPMHOOK_pre_pc_checkallowskill) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_checkallowskill) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_checkequip) (struct map_session_data **sd, int *pos); +typedef int (*HPMHOOK_post_pc_checkequip) (int retVal___, struct map_session_data *sd, int pos); +typedef int (*HPMHOOK_pre_pc_calc_skilltree) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_calc_skilltree) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_calc_skilltree_normalize_job) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_calc_skilltree_normalize_job) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_clean_skilltree) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_clean_skilltree) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_setpos) (struct map_session_data **sd, unsigned short *map_index, int *x, int *y, clr_type *clrtype); +typedef int (*HPMHOOK_post_pc_setpos) (int retVal___, struct map_session_data *sd, unsigned short map_index, int x, int y, clr_type clrtype); +typedef int (*HPMHOOK_pre_pc_setsavepoint) (struct map_session_data **sd, short *map_index, int *x, int *y); +typedef int (*HPMHOOK_post_pc_setsavepoint) (int retVal___, struct map_session_data *sd, short map_index, int x, int y); +typedef int (*HPMHOOK_pre_pc_randomwarp) (struct map_session_data **sd, clr_type *type); +typedef int (*HPMHOOK_post_pc_randomwarp) (int retVal___, struct map_session_data *sd, clr_type type); +typedef int (*HPMHOOK_pre_pc_memo) (struct map_session_data **sd, int *pos); +typedef int (*HPMHOOK_post_pc_memo) (int retVal___, struct map_session_data *sd, int pos); +typedef int (*HPMHOOK_pre_pc_checkadditem) (struct map_session_data **sd, int *nameid, int *amount); +typedef int (*HPMHOOK_post_pc_checkadditem) (int retVal___, struct map_session_data *sd, int nameid, int amount); +typedef int (*HPMHOOK_pre_pc_inventoryblank) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_inventoryblank) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_search_inventory) (struct map_session_data **sd, int *item_id); +typedef int (*HPMHOOK_post_pc_search_inventory) (int retVal___, struct map_session_data *sd, int item_id); +typedef int (*HPMHOOK_pre_pc_payzeny) (struct map_session_data **sd, int *zeny, enum e_log_pick_type *type, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_pc_payzeny) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd); +typedef int (*HPMHOOK_pre_pc_additem) (struct map_session_data **sd, struct item **item_data, int *amount, e_log_pick_type *log_type); +typedef int (*HPMHOOK_post_pc_additem) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type); +typedef int (*HPMHOOK_pre_pc_getzeny) (struct map_session_data **sd, int *zeny, enum e_log_pick_type *type, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_pc_getzeny) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd); +typedef int (*HPMHOOK_pre_pc_delitem) (struct map_session_data **sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type); +typedef int (*HPMHOOK_post_pc_delitem) (int retVal___, struct map_session_data *sd, int n, int amount, int type, short reason, e_log_pick_type log_type); +typedef int (*HPMHOOK_pre_pc_paycash) (struct map_session_data **sd, int *price, int *points); +typedef int (*HPMHOOK_post_pc_paycash) (int retVal___, struct map_session_data *sd, int price, int points); +typedef int (*HPMHOOK_pre_pc_getcash) (struct map_session_data **sd, int *cash, int *points); +typedef int (*HPMHOOK_post_pc_getcash) (int retVal___, struct map_session_data *sd, int cash, int points); +typedef int (*HPMHOOK_pre_pc_cart_additem) (struct map_session_data **sd, struct item **item_data, int *amount, e_log_pick_type *log_type); +typedef int (*HPMHOOK_post_pc_cart_additem) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type); +typedef int (*HPMHOOK_pre_pc_cart_delitem) (struct map_session_data **sd, int *n, int *amount, int *type, e_log_pick_type *log_type); +typedef int (*HPMHOOK_post_pc_cart_delitem) (int retVal___, struct map_session_data *sd, int n, int amount, int type, e_log_pick_type log_type); +typedef int (*HPMHOOK_pre_pc_putitemtocart) (struct map_session_data **sd, int *idx, int *amount); +typedef int (*HPMHOOK_post_pc_putitemtocart) (int retVal___, struct map_session_data *sd, int idx, int amount); +typedef int (*HPMHOOK_pre_pc_getitemfromcart) (struct map_session_data **sd, int *idx, int *amount); +typedef int (*HPMHOOK_post_pc_getitemfromcart) (int retVal___, struct map_session_data *sd, int idx, int amount); +typedef int (*HPMHOOK_pre_pc_cartitem_amount) (struct map_session_data **sd, int *idx, int *amount); +typedef int (*HPMHOOK_post_pc_cartitem_amount) (int retVal___, struct map_session_data *sd, int idx, int amount); +typedef int (*HPMHOOK_pre_pc_takeitem) (struct map_session_data **sd, struct flooritem_data **fitem); +typedef int (*HPMHOOK_post_pc_takeitem) (int retVal___, struct map_session_data *sd, struct flooritem_data *fitem); +typedef int (*HPMHOOK_pre_pc_dropitem) (struct map_session_data **sd, int *n, int *amount); +typedef int (*HPMHOOK_post_pc_dropitem) (int retVal___, struct map_session_data *sd, int n, int amount); +typedef bool (*HPMHOOK_pre_pc_isequipped) (struct map_session_data **sd, int *nameid); +typedef bool (*HPMHOOK_post_pc_isequipped) (bool retVal___, struct map_session_data *sd, int nameid); +typedef bool (*HPMHOOK_pre_pc_can_Adopt) (struct map_session_data **p1_sd, struct map_session_data **p2_sd, struct map_session_data **b_sd); +typedef bool (*HPMHOOK_post_pc_can_Adopt) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd); +typedef bool (*HPMHOOK_pre_pc_adoption) (struct map_session_data **p1_sd, struct map_session_data **p2_sd, struct map_session_data **b_sd); +typedef bool (*HPMHOOK_post_pc_adoption) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd); +typedef int (*HPMHOOK_pre_pc_updateweightstatus) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_updateweightstatus) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_addautobonus) (struct s_autobonus **bonus, char *max, const char **bonus_script, short *rate, unsigned int *dur, short *atk_type, const char **o_script, unsigned short *pos, bool *onskill); +typedef int (*HPMHOOK_post_pc_addautobonus) (int retVal___, struct s_autobonus *bonus, char max, const char *bonus_script, short rate, unsigned int dur, short atk_type, const char *o_script, unsigned short pos, bool onskill); +typedef int (*HPMHOOK_pre_pc_exeautobonus) (struct map_session_data **sd, struct s_autobonus **bonus); +typedef int (*HPMHOOK_post_pc_exeautobonus) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus); +typedef int (*HPMHOOK_pre_pc_endautobonus) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_endautobonus) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_delautobonus) (struct map_session_data **sd, struct s_autobonus **bonus, char *max, bool *restore); +typedef int (*HPMHOOK_post_pc_delautobonus) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus, char max, bool restore); +typedef int (*HPMHOOK_pre_pc_bonus) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_bonus) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_bonus2) (struct map_session_data **sd, int *type, int *type2, int *val); +typedef int (*HPMHOOK_post_pc_bonus2) (int retVal___, struct map_session_data *sd, int type, int type2, int val); +typedef int (*HPMHOOK_pre_pc_bonus3) (struct map_session_data **sd, int *type, int *type2, int *type3, int *val); +typedef int (*HPMHOOK_post_pc_bonus3) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int val); +typedef int (*HPMHOOK_pre_pc_bonus4) (struct map_session_data **sd, int *type, int *type2, int *type3, int *type4, int *val); +typedef int (*HPMHOOK_post_pc_bonus4) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int val); +typedef int (*HPMHOOK_pre_pc_bonus5) (struct map_session_data **sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val); +typedef int (*HPMHOOK_post_pc_bonus5) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int type5, int val); +typedef int (*HPMHOOK_pre_pc_skill) (struct map_session_data **sd, int *id, int *level, int *flag); +typedef int (*HPMHOOK_post_pc_skill) (int retVal___, struct map_session_data *sd, int id, int level, int flag); +typedef int (*HPMHOOK_pre_pc_insert_card) (struct map_session_data **sd, int *idx_card, int *idx_equip); +typedef int (*HPMHOOK_post_pc_insert_card) (int retVal___, struct map_session_data *sd, int idx_card, int idx_equip); +typedef bool (*HPMHOOK_pre_pc_can_insert_card) (struct map_session_data **sd, int *idx_card); +typedef bool (*HPMHOOK_post_pc_can_insert_card) (bool retVal___, struct map_session_data *sd, int idx_card); +typedef bool (*HPMHOOK_pre_pc_can_insert_card_into) (struct map_session_data **sd, int *idx_card, int *idx_equip); +typedef bool (*HPMHOOK_post_pc_can_insert_card_into) (bool retVal___, struct map_session_data *sd, int idx_card, int idx_equip); +typedef int (*HPMHOOK_pre_pc_steal_item) (struct map_session_data **sd, struct block_list **bl, uint16 *skill_lv); +typedef int (*HPMHOOK_post_pc_steal_item) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_lv); +typedef int (*HPMHOOK_pre_pc_steal_coin) (struct map_session_data **sd, struct block_list **bl); +typedef int (*HPMHOOK_post_pc_steal_coin) (int retVal___, struct map_session_data *sd, struct block_list *bl); +typedef int (*HPMHOOK_pre_pc_modifybuyvalue) (struct map_session_data **sd, int *orig_value); +typedef int (*HPMHOOK_post_pc_modifybuyvalue) (int retVal___, struct map_session_data *sd, int orig_value); +typedef int (*HPMHOOK_pre_pc_modifysellvalue) (struct map_session_data **sd, int *orig_value); +typedef int (*HPMHOOK_post_pc_modifysellvalue) (int retVal___, struct map_session_data *sd, int orig_value); +typedef int (*HPMHOOK_pre_pc_follow) (struct map_session_data **sd, int *target_id); +typedef int (*HPMHOOK_post_pc_follow) (int retVal___, struct map_session_data *sd, int target_id); +typedef int (*HPMHOOK_pre_pc_stop_following) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_stop_following) (int retVal___, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_pc_maxbaselv) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_maxbaselv) (unsigned int retVal___, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_pc_maxjoblv) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_maxjoblv) (unsigned int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_checkbaselevelup) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_checkbaselevelup) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_checkjoblevelup) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_checkjoblevelup) (int retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_pc_gainexp) (struct map_session_data **sd, struct block_list **src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest); +typedef bool (*HPMHOOK_post_pc_gainexp) (bool retVal___, struct map_session_data *sd, struct block_list *src, unsigned int base_exp, unsigned int job_exp, bool is_quest); +typedef unsigned int (*HPMHOOK_pre_pc_nextbaseexp) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_nextbaseexp) (unsigned int retVal___, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_pc_thisbaseexp) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_thisbaseexp) (unsigned int retVal___, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_pc_nextjobexp) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_nextjobexp) (unsigned int retVal___, struct map_session_data *sd); +typedef unsigned int (*HPMHOOK_pre_pc_thisjobexp) (struct map_session_data **sd); +typedef unsigned int (*HPMHOOK_post_pc_thisjobexp) (unsigned int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_gets_status_point) (int *level); +typedef int (*HPMHOOK_post_pc_gets_status_point) (int retVal___, int level); +typedef int (*HPMHOOK_pre_pc_need_status_point) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_need_status_point) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_maxparameterincrease) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_maxparameterincrease) (int retVal___, struct map_session_data *sd, int type); +typedef bool (*HPMHOOK_pre_pc_statusup) (struct map_session_data **sd, int *type, int *increase); +typedef bool (*HPMHOOK_post_pc_statusup) (bool retVal___, struct map_session_data *sd, int type, int increase); +typedef int (*HPMHOOK_pre_pc_statusup2) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_statusup2) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_skillup) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_pc_skillup) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_pc_allskillup) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_allskillup) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_resetlvl) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_resetlvl) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pc_resetstate) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_resetstate) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_resetskill) (struct map_session_data **sd, int *flag); +typedef int (*HPMHOOK_post_pc_resetskill) (int retVal___, struct map_session_data *sd, int flag); +typedef int (*HPMHOOK_pre_pc_resetfeel) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_resetfeel) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_resethate) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_resethate) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_equipitem) (struct map_session_data **sd, int *n, int *req_pos); +typedef int (*HPMHOOK_post_pc_equipitem) (int retVal___, struct map_session_data *sd, int n, int req_pos); +typedef void (*HPMHOOK_pre_pc_equipitem_pos) (struct map_session_data **sd, struct item_data **id, int *n, int *pos); +typedef void (*HPMHOOK_post_pc_equipitem_pos) (struct map_session_data *sd, struct item_data *id, int n, int pos); +typedef int (*HPMHOOK_pre_pc_unequipitem) (struct map_session_data **sd, int *n, int *flag); +typedef int (*HPMHOOK_post_pc_unequipitem) (int retVal___, struct map_session_data *sd, int n, int flag); +typedef void (*HPMHOOK_pre_pc_unequipitem_pos) (struct map_session_data **sd, int *n, int *pos); +typedef void (*HPMHOOK_post_pc_unequipitem_pos) (struct map_session_data *sd, int n, int pos); +typedef int (*HPMHOOK_pre_pc_checkitem) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_checkitem) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_useitem) (struct map_session_data **sd, int *n); +typedef int (*HPMHOOK_post_pc_useitem) (int retVal___, struct map_session_data *sd, int n); +typedef int (*HPMHOOK_pre_pc_skillatk_bonus) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_pc_skillatk_bonus) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_pc_skillheal_bonus) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_pc_skillheal_bonus) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_pc_skillheal2_bonus) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_pc_skillheal2_bonus) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef void (*HPMHOOK_pre_pc_damage) (struct map_session_data **sd, struct block_list **src, unsigned int *hp, unsigned int *sp); +typedef void (*HPMHOOK_post_pc_damage) (struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp); +typedef int (*HPMHOOK_pre_pc_dead) (struct map_session_data **sd, struct block_list **src); +typedef int (*HPMHOOK_post_pc_dead) (int retVal___, struct map_session_data *sd, struct block_list *src); +typedef void (*HPMHOOK_pre_pc_revive) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp); +typedef void (*HPMHOOK_post_pc_revive) (struct map_session_data *sd, unsigned int hp, unsigned int sp); +typedef void (*HPMHOOK_pre_pc_heal) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp, int *type); +typedef void (*HPMHOOK_post_pc_heal) (struct map_session_data *sd, unsigned int hp, unsigned int sp, int type); +typedef int (*HPMHOOK_pre_pc_itemheal) (struct map_session_data **sd, int *itemid, int *hp, int *sp); +typedef int (*HPMHOOK_post_pc_itemheal) (int retVal___, struct map_session_data *sd, int itemid, int hp, int sp); +typedef int (*HPMHOOK_pre_pc_percentheal) (struct map_session_data **sd, int *hp, int *sp); +typedef int (*HPMHOOK_post_pc_percentheal) (int retVal___, struct map_session_data *sd, int hp, int sp); +typedef int (*HPMHOOK_pre_pc_jobchange) (struct map_session_data **sd, int *job, int *upper); +typedef int (*HPMHOOK_post_pc_jobchange) (int retVal___, struct map_session_data *sd, int job, int upper); +typedef int (*HPMHOOK_pre_pc_setoption) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_setoption) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pc_setcart) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_setcart) (int retVal___, struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_pc_setfalcon) (struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_pc_setfalcon) (struct map_session_data *sd, bool flag); +typedef void (*HPMHOOK_pre_pc_setridingpeco) (struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_pc_setridingpeco) (struct map_session_data *sd, bool flag); +typedef void (*HPMHOOK_pre_pc_setmadogear) (struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_pc_setmadogear) (struct map_session_data *sd, bool flag); +typedef void (*HPMHOOK_pre_pc_setridingdragon) (struct map_session_data **sd, unsigned int *type); +typedef void (*HPMHOOK_post_pc_setridingdragon) (struct map_session_data *sd, unsigned int type); +typedef void (*HPMHOOK_pre_pc_setridingwug) (struct map_session_data **sd, bool *flag); +typedef void (*HPMHOOK_post_pc_setridingwug) (struct map_session_data *sd, bool flag); +typedef int (*HPMHOOK_pre_pc_changelook) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_changelook) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_equiplookall) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_equiplookall) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_readparam) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_readparam) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pc_setparam) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_setparam) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_readreg) (struct map_session_data **sd, int64 *reg); +typedef int (*HPMHOOK_post_pc_readreg) (int retVal___, struct map_session_data *sd, int64 reg); +typedef void (*HPMHOOK_pre_pc_setreg) (struct map_session_data **sd, int64 *reg, int *val); +typedef void (*HPMHOOK_post_pc_setreg) (struct map_session_data *sd, int64 reg, int val); +typedef char* (*HPMHOOK_pre_pc_readregstr) (struct map_session_data **sd, int64 *reg); +typedef char* (*HPMHOOK_post_pc_readregstr) (char* retVal___, struct map_session_data *sd, int64 reg); +typedef void (*HPMHOOK_pre_pc_setregstr) (struct map_session_data **sd, int64 *reg, const char **str); +typedef void (*HPMHOOK_post_pc_setregstr) (struct map_session_data *sd, int64 reg, const char *str); +typedef int (*HPMHOOK_pre_pc_readregistry) (struct map_session_data **sd, int64 *reg); +typedef int (*HPMHOOK_post_pc_readregistry) (int retVal___, struct map_session_data *sd, int64 reg); +typedef int (*HPMHOOK_pre_pc_setregistry) (struct map_session_data **sd, int64 *reg, int *val); +typedef int (*HPMHOOK_post_pc_setregistry) (int retVal___, struct map_session_data *sd, int64 reg, int val); +typedef char* (*HPMHOOK_pre_pc_readregistry_str) (struct map_session_data **sd, int64 *reg); +typedef char* (*HPMHOOK_post_pc_readregistry_str) (char* retVal___, struct map_session_data *sd, int64 reg); +typedef int (*HPMHOOK_pre_pc_setregistry_str) (struct map_session_data **sd, int64 *reg, const char **val); +typedef int (*HPMHOOK_post_pc_setregistry_str) (int retVal___, struct map_session_data *sd, int64 reg, const char *val); +typedef int (*HPMHOOK_pre_pc_addeventtimer) (struct map_session_data **sd, int *tick, const char **name); +typedef int (*HPMHOOK_post_pc_addeventtimer) (int retVal___, struct map_session_data *sd, int tick, const char *name); +typedef int (*HPMHOOK_pre_pc_deleventtimer) (struct map_session_data **sd, const char **name); +typedef int (*HPMHOOK_post_pc_deleventtimer) (int retVal___, struct map_session_data *sd, const char *name); +typedef int (*HPMHOOK_pre_pc_cleareventtimer) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_cleareventtimer) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_addeventtimercount) (struct map_session_data **sd, const char **name, int *tick); +typedef int (*HPMHOOK_post_pc_addeventtimercount) (int retVal___, struct map_session_data *sd, const char *name, int tick); +typedef int (*HPMHOOK_pre_pc_calc_pvprank) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_calc_pvprank) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_calc_pvprank_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_calc_pvprank_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_ismarried) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_ismarried) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_marriage) (struct map_session_data **sd, struct map_session_data **dstsd); +typedef int (*HPMHOOK_post_pc_marriage) (int retVal___, struct map_session_data *sd, struct map_session_data *dstsd); +typedef int (*HPMHOOK_pre_pc_divorce) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_divorce) (int retVal___, struct map_session_data *sd); +typedef struct map_session_data* (*HPMHOOK_pre_pc_get_partner) (struct map_session_data **sd); +typedef struct map_session_data* (*HPMHOOK_post_pc_get_partner) (struct map_session_data* retVal___, struct map_session_data *sd); +typedef struct map_session_data* (*HPMHOOK_pre_pc_get_father) (struct map_session_data **sd); +typedef struct map_session_data* (*HPMHOOK_post_pc_get_father) (struct map_session_data* retVal___, struct map_session_data *sd); +typedef struct map_session_data* (*HPMHOOK_pre_pc_get_mother) (struct map_session_data **sd); +typedef struct map_session_data* (*HPMHOOK_post_pc_get_mother) (struct map_session_data* retVal___, struct map_session_data *sd); +typedef struct map_session_data* (*HPMHOOK_pre_pc_get_child) (struct map_session_data **sd); +typedef struct map_session_data* (*HPMHOOK_post_pc_get_child) (struct map_session_data* retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_bleeding) (struct map_session_data **sd, unsigned int *diff_tick); +typedef void (*HPMHOOK_post_pc_bleeding) (struct map_session_data *sd, unsigned int diff_tick); +typedef void (*HPMHOOK_pre_pc_regen) (struct map_session_data **sd, unsigned int *diff_tick); +typedef void (*HPMHOOK_post_pc_regen) (struct map_session_data *sd, unsigned int diff_tick); +typedef void (*HPMHOOK_pre_pc_setstand) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_setstand) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_candrop) (struct map_session_data **sd, struct item **item); +typedef int (*HPMHOOK_post_pc_candrop) (int retVal___, struct map_session_data *sd, struct item *item); +typedef int (*HPMHOOK_pre_pc_jobid2mapid) (unsigned short *b_class); +typedef int (*HPMHOOK_post_pc_jobid2mapid) (int retVal___, unsigned short b_class); +typedef int (*HPMHOOK_pre_pc_mapid2jobid) (unsigned short *class_, int *sex); +typedef int (*HPMHOOK_post_pc_mapid2jobid) (int retVal___, unsigned short class_, int sex); +typedef const char* (*HPMHOOK_pre_pc_job_name) (int *class_); +typedef const char* (*HPMHOOK_post_pc_job_name) (const char* retVal___, int class_); +typedef void (*HPMHOOK_pre_pc_setinvincibletimer) (struct map_session_data **sd, int *val); +typedef void (*HPMHOOK_post_pc_setinvincibletimer) (struct map_session_data *sd, int val); +typedef void (*HPMHOOK_pre_pc_delinvincibletimer) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_delinvincibletimer) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_addspiritball) (struct map_session_data **sd, int *interval, int *max); +typedef int (*HPMHOOK_post_pc_addspiritball) (int retVal___, struct map_session_data *sd, int interval, int max); +typedef int (*HPMHOOK_pre_pc_delspiritball) (struct map_session_data **sd, int *count, int *type); +typedef int (*HPMHOOK_post_pc_delspiritball) (int retVal___, struct map_session_data *sd, int count, int type); +typedef int (*HPMHOOK_pre_pc_getmaxspiritball) (struct map_session_data **sd, int *min); +typedef int (*HPMHOOK_post_pc_getmaxspiritball) (int retVal___, struct map_session_data *sd, int min); +typedef void (*HPMHOOK_pre_pc_addfame) (struct map_session_data **sd, int *count); +typedef void (*HPMHOOK_post_pc_addfame) (struct map_session_data *sd, int count); +typedef unsigned char (*HPMHOOK_pre_pc_famerank) (int *char_id, int *job); +typedef unsigned char (*HPMHOOK_post_pc_famerank) (unsigned char retVal___, int char_id, int job); +typedef int (*HPMHOOK_pre_pc_set_hate_mob) (struct map_session_data **sd, int *pos, struct block_list **bl); +typedef int (*HPMHOOK_post_pc_set_hate_mob) (int retVal___, struct map_session_data *sd, int pos, struct block_list *bl); +typedef int (*HPMHOOK_pre_pc_readdb) (void); +typedef int (*HPMHOOK_post_pc_readdb) (int retVal___); +typedef int (*HPMHOOK_pre_pc_map_day_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_map_day_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_map_night_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_map_night_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_pc_inventory_rentals) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_inventory_rentals) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_inventory_rental_clear) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_inventory_rental_clear) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_inventory_rental_add) (struct map_session_data **sd, int *seconds); +typedef void (*HPMHOOK_post_pc_inventory_rental_add) (struct map_session_data *sd, int seconds); +typedef int (*HPMHOOK_pre_pc_disguise) (struct map_session_data **sd, int *class_); +typedef int (*HPMHOOK_post_pc_disguise) (int retVal___, struct map_session_data *sd, int class_); +typedef bool (*HPMHOOK_pre_pc_isautolooting) (struct map_session_data **sd, int *nameid); +typedef bool (*HPMHOOK_post_pc_isautolooting) (bool retVal___, struct map_session_data *sd, int nameid); +typedef void (*HPMHOOK_pre_pc_overheat) (struct map_session_data **sd, int *val); +typedef void (*HPMHOOK_post_pc_overheat) (struct map_session_data *sd, int val); +typedef int (*HPMHOOK_pre_pc_banding) (struct map_session_data **sd, uint16 *skill_lv); +typedef int (*HPMHOOK_post_pc_banding) (int retVal___, struct map_session_data *sd, uint16 skill_lv); +typedef void (*HPMHOOK_pre_pc_itemcd_do) (struct map_session_data **sd, bool *load); +typedef void (*HPMHOOK_post_pc_itemcd_do) (struct map_session_data *sd, bool load); +typedef int (*HPMHOOK_pre_pc_load_combo) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_load_combo) (int retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_add_charm) (struct map_session_data **sd, int *interval, int *max, int *type); +typedef void (*HPMHOOK_post_pc_add_charm) (struct map_session_data *sd, int interval, int max, int type); +typedef void (*HPMHOOK_pre_pc_del_charm) (struct map_session_data **sd, int *count, int *type); +typedef void (*HPMHOOK_post_pc_del_charm) (struct map_session_data *sd, int count, int type); +typedef void (*HPMHOOK_pre_pc_baselevelchanged) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_baselevelchanged) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_level_penalty_mod) (int *diff, unsigned char *race, uint32 *mode, int *type); +typedef int (*HPMHOOK_post_pc_level_penalty_mod) (int retVal___, int diff, unsigned char race, uint32 mode, int type); +typedef int (*HPMHOOK_pre_pc_calc_skillpoint) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_calc_skillpoint) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_invincible_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_invincible_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_spiritball_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_spiritball_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_check_banding) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_pc_check_banding) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_pc_inventory_rental_end) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_inventory_rental_end) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_pc_check_skilltree) (struct map_session_data **sd, int *skill_id); +typedef void (*HPMHOOK_post_pc_check_skilltree) (struct map_session_data *sd, int skill_id); +typedef int (*HPMHOOK_pre_pc_bonus_autospell) (struct s_autospell **spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id); +typedef int (*HPMHOOK_post_pc_bonus_autospell) (int retVal___, struct s_autospell *spell, int max, short id, short lv, short rate, short flag, short card_id); +typedef int (*HPMHOOK_pre_pc_bonus_autospell_onskill) (struct s_autospell **spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id); +typedef int (*HPMHOOK_post_pc_bonus_autospell_onskill) (int retVal___, struct s_autospell *spell, int max, short src_skill, short id, short lv, short rate, short card_id); +typedef int (*HPMHOOK_pre_pc_bonus_addeff) (struct s_addeffect **effect, int *max, enum sc_type *id, int16 *rate, int16 *arrow_rate, uint8 *flag, uint16 *duration); +typedef int (*HPMHOOK_post_pc_bonus_addeff) (int retVal___, struct s_addeffect *effect, int max, enum sc_type id, int16 rate, int16 arrow_rate, uint8 flag, uint16 duration); +typedef int (*HPMHOOK_pre_pc_bonus_addeff_onskill) (struct s_addeffectonskill **effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target); +typedef int (*HPMHOOK_post_pc_bonus_addeff_onskill) (int retVal___, struct s_addeffectonskill *effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target); +typedef int (*HPMHOOK_pre_pc_bonus_item_drop) (struct s_add_drop **drop, const short *max, short *id, short *group, int *race, int *rate); +typedef int (*HPMHOOK_post_pc_bonus_item_drop) (int retVal___, struct s_add_drop *drop, const short max, short id, short group, int race, int rate); +typedef void (*HPMHOOK_pre_pc_calcexp) (struct map_session_data **sd, unsigned int **base_exp, unsigned int **job_exp, struct block_list **src); +typedef void (*HPMHOOK_post_pc_calcexp) (struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src); +typedef int (*HPMHOOK_pre_pc_respawn_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_respawn_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_jobchange_killclone) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_pc_jobchange_killclone) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_pc_getstat) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pc_getstat) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pc_setstat) (struct map_session_data **sd, int *type, int *val); +typedef int (*HPMHOOK_post_pc_setstat) (int retVal___, struct map_session_data *sd, int type, int val); +typedef int (*HPMHOOK_pre_pc_eventtimer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_eventtimer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_daynight_timer_sub) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_pc_daynight_timer_sub) (int retVal___, struct map_session_data *sd, va_list ap); +typedef int (*HPMHOOK_pre_pc_charm_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_charm_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef bool (*HPMHOOK_pre_pc_readdb_levelpenalty) (char **fields[], int *columns, int *current); +typedef bool (*HPMHOOK_post_pc_readdb_levelpenalty) (bool retVal___, char *fields[], int columns, int current); +typedef int (*HPMHOOK_pre_pc_autosave) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_autosave) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_follow_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_follow_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_pc_read_skill_tree) (void); +typedef void (*HPMHOOK_post_pc_read_skill_tree) (void); +typedef void (*HPMHOOK_pre_pc_clear_skill_tree) (void); +typedef void (*HPMHOOK_post_pc_clear_skill_tree) (void); +typedef int (*HPMHOOK_pre_pc_isUseitem) (struct map_session_data **sd, int *n); +typedef int (*HPMHOOK_post_pc_isUseitem) (int retVal___, struct map_session_data *sd, int n); +typedef int (*HPMHOOK_pre_pc_show_steal) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_pc_show_steal) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_pc_checkcombo) (struct map_session_data **sd, struct item_data **data); +typedef int (*HPMHOOK_post_pc_checkcombo) (int retVal___, struct map_session_data *sd, struct item_data *data); +typedef int (*HPMHOOK_pre_pc_calcweapontype) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_calcweapontype) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_removecombo) (struct map_session_data **sd, struct item_data **data); +typedef int (*HPMHOOK_post_pc_removecombo) (int retVal___, struct map_session_data *sd, struct item_data *data); +typedef void (*HPMHOOK_pre_pc_bank_deposit) (struct map_session_data **sd, int *money); +typedef void (*HPMHOOK_post_pc_bank_deposit) (struct map_session_data *sd, int money); +typedef void (*HPMHOOK_pre_pc_bank_withdraw) (struct map_session_data **sd, int *money); +typedef void (*HPMHOOK_post_pc_bank_withdraw) (struct map_session_data *sd, int money); +typedef void (*HPMHOOK_pre_pc_rental_expire) (struct map_session_data **sd, int *i); +typedef void (*HPMHOOK_post_pc_rental_expire) (struct map_session_data *sd, int i); +typedef void (*HPMHOOK_pre_pc_scdata_received) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_scdata_received) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_bound_clear) (struct map_session_data **sd, enum e_item_bound_type *type); +typedef void (*HPMHOOK_post_pc_bound_clear) (struct map_session_data *sd, enum e_item_bound_type type); +typedef int (*HPMHOOK_pre_pc_expiration_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_expiration_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pc_global_expiration_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pc_global_expiration_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_pc_expire_check) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_expire_check) (struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_pc_db_checkid) (unsigned int *class_); +typedef bool (*HPMHOOK_post_pc_db_checkid) (bool retVal___, unsigned int class_); +typedef void (*HPMHOOK_pre_pc_validate_levels) (void); +typedef void (*HPMHOOK_post_pc_validate_levels) (void); +typedef void (*HPMHOOK_pre_pc_autotrade_load) (void); +typedef void (*HPMHOOK_post_pc_autotrade_load) (void); +typedef void (*HPMHOOK_pre_pc_autotrade_update) (struct map_session_data **sd, enum e_pc_autotrade_update_action *action); +typedef void (*HPMHOOK_post_pc_autotrade_update) (struct map_session_data *sd, enum e_pc_autotrade_update_action action); +typedef void (*HPMHOOK_pre_pc_autotrade_start) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_autotrade_start) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_autotrade_prepare) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_autotrade_prepare) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_pc_autotrade_populate) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_pc_autotrade_populate) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pc_autotrade_final) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_pc_autotrade_final) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef int (*HPMHOOK_pre_pc_check_job_name) (const char **name); +typedef int (*HPMHOOK_post_pc_check_job_name) (int retVal___, const char *name); +typedef void (*HPMHOOK_pre_pc_update_idle_time) (struct map_session_data **sd, enum e_battle_config_idletime *type); +typedef void (*HPMHOOK_post_pc_update_idle_time) (struct map_session_data *sd, enum e_battle_config_idletime type); +typedef int (*HPMHOOK_pre_pc_have_magnifier) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_pc_have_magnifier) (int retVal___, struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_pc_process_chat_message) (struct map_session_data **sd, const char **message); +typedef bool (*HPMHOOK_post_pc_process_chat_message) (bool retVal___, struct map_session_data *sd, const char *message); +typedef void (*HPMHOOK_pre_pc_check_supernovice_call) (struct map_session_data **sd, const char **message); +typedef void (*HPMHOOK_post_pc_check_supernovice_call) (struct map_session_data *sd, const char *message); +#endif // MAP_PC_H +#ifdef MAP_NPC_H /* libpcre */ +typedef pcre* (*HPMHOOK_pre_libpcre_compile) (const char **pattern, int *options, const char ***errptr, int **erroffset, const unsigned char **tableptr); +typedef pcre* (*HPMHOOK_post_libpcre_compile) (pcre* retVal___, const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr); +typedef pcre_extra* (*HPMHOOK_pre_libpcre_study) (const pcre **code, int *options, const char ***errptr); +typedef pcre_extra* (*HPMHOOK_post_libpcre_study) (pcre_extra* retVal___, const pcre *code, int options, const char **errptr); +typedef int (*HPMHOOK_pre_libpcre_exec) (const pcre **code, const pcre_extra **extra, PCRE_SPTR *subject, int *length, int *startoffset, int *options, int **ovector, int *ovecsize); +typedef int (*HPMHOOK_post_libpcre_exec) (int retVal___, const pcre *code, const pcre_extra *extra, PCRE_SPTR subject, int length, int startoffset, int options, int *ovector, int ovecsize); +typedef void (*HPMHOOK_pre_libpcre_free) (void **ptr); +typedef void (*HPMHOOK_post_libpcre_free) (void *ptr); +typedef int (*HPMHOOK_pre_libpcre_copy_substring) (const char **subject, int **ovector, int *stringcount, int *stringnumber, char **buffer, int *buffersize); +typedef int (*HPMHOOK_post_libpcre_copy_substring) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int buffersize); +typedef void (*HPMHOOK_pre_libpcre_free_substring) (const char **stringptr); +typedef void (*HPMHOOK_post_libpcre_free_substring) (const char *stringptr); +typedef int (*HPMHOOK_pre_libpcre_copy_named_substring) (const pcre **code, const char **subject, int **ovector, int *stringcount, const char **stringname, char **buffer, int *buffersize); +typedef int (*HPMHOOK_post_libpcre_copy_named_substring) (int retVal___, const pcre *code, const char *subject, int *ovector, int stringcount, const char *stringname, char *buffer, int buffersize); +typedef int (*HPMHOOK_pre_libpcre_get_substring) (const char **subject, int **ovector, int *stringcount, int *stringnumber, const char ***stringptr); +typedef int (*HPMHOOK_post_libpcre_get_substring) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, const char **stringptr); +#endif // MAP_NPC_H +#ifdef MAP_PET_H /* pet */ +typedef int (*HPMHOOK_pre_pet_init) (bool *minimal); +typedef int (*HPMHOOK_post_pet_init) (int retVal___, bool minimal); +typedef int (*HPMHOOK_pre_pet_final) (void); +typedef int (*HPMHOOK_post_pet_final) (int retVal___); +typedef int (*HPMHOOK_pre_pet_hungry_val) (struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_hungry_val) (int retVal___, struct pet_data *pd); +typedef void (*HPMHOOK_pre_pet_set_intimate) (struct pet_data **pd, int *value); +typedef void (*HPMHOOK_post_pet_set_intimate) (struct pet_data *pd, int value); +typedef int (*HPMHOOK_pre_pet_create_egg) (struct map_session_data **sd, int *item_id); +typedef int (*HPMHOOK_post_pet_create_egg) (int retVal___, struct map_session_data *sd, int item_id); +typedef int (*HPMHOOK_pre_pet_unlocktarget) (struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_unlocktarget) (int retVal___, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_attackskill) (struct pet_data **pd, int *target_id); +typedef int (*HPMHOOK_post_pet_attackskill) (int retVal___, struct pet_data *pd, int target_id); +typedef int (*HPMHOOK_pre_pet_target_check) (struct map_session_data **sd, struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_pet_target_check) (int retVal___, struct map_session_data *sd, struct block_list *bl, int type); +typedef int (*HPMHOOK_pre_pet_sc_check) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_pet_sc_check) (int retVal___, struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_pet_hungry) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_hungry) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_search_petDB_index) (int *key, int *type); +typedef int (*HPMHOOK_post_pet_search_petDB_index) (int retVal___, int key, int type); +typedef int (*HPMHOOK_pre_pet_hungry_timer_delete) (struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_hungry_timer_delete) (int retVal___, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_performance) (struct map_session_data **sd, struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_performance) (int retVal___, struct map_session_data *sd, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_return_egg) (struct map_session_data **sd, struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_return_egg) (int retVal___, struct map_session_data *sd, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_data_init) (struct map_session_data **sd, struct s_pet **petinfo); +typedef int (*HPMHOOK_post_pet_data_init) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo); +typedef int (*HPMHOOK_pre_pet_birth_process) (struct map_session_data **sd, struct s_pet **petinfo); +typedef int (*HPMHOOK_post_pet_birth_process) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo); +typedef int (*HPMHOOK_pre_pet_recv_petdata) (int *account_id, struct s_pet **p, int *flag); +typedef int (*HPMHOOK_post_pet_recv_petdata) (int retVal___, int account_id, struct s_pet *p, int flag); +typedef int (*HPMHOOK_pre_pet_select_egg) (struct map_session_data **sd, short *egg_index); +typedef int (*HPMHOOK_post_pet_select_egg) (int retVal___, struct map_session_data *sd, short egg_index); +typedef int (*HPMHOOK_pre_pet_catch_process1) (struct map_session_data **sd, int *target_class); +typedef int (*HPMHOOK_post_pet_catch_process1) (int retVal___, struct map_session_data *sd, int target_class); +typedef int (*HPMHOOK_pre_pet_catch_process2) (struct map_session_data **sd, int *target_id); +typedef int (*HPMHOOK_post_pet_catch_process2) (int retVal___, struct map_session_data *sd, int target_id); +typedef bool (*HPMHOOK_pre_pet_get_egg) (int *account_id, short *pet_class, int *pet_id); +typedef bool (*HPMHOOK_post_pet_get_egg) (bool retVal___, int account_id, short pet_class, int pet_id); +typedef int (*HPMHOOK_pre_pet_unequipitem) (struct map_session_data **sd, struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_unequipitem) (int retVal___, struct map_session_data *sd, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_food) (struct map_session_data **sd, struct pet_data **pd); +typedef int (*HPMHOOK_post_pet_food) (int retVal___, struct map_session_data *sd, struct pet_data *pd); +typedef int (*HPMHOOK_pre_pet_ai_sub_hard_lootsearch) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_pet_ai_sub_hard_lootsearch) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_pet_menu) (struct map_session_data **sd, int *menunum); +typedef int (*HPMHOOK_post_pet_menu) (int retVal___, struct map_session_data *sd, int menunum); +typedef int (*HPMHOOK_pre_pet_change_name) (struct map_session_data **sd, const char **name); +typedef int (*HPMHOOK_post_pet_change_name) (int retVal___, struct map_session_data *sd, const char *name); +typedef int (*HPMHOOK_pre_pet_change_name_ack) (struct map_session_data **sd, const char **name, int *flag); +typedef int (*HPMHOOK_post_pet_change_name_ack) (int retVal___, struct map_session_data *sd, const char *name, int flag); +typedef int (*HPMHOOK_pre_pet_equipitem) (struct map_session_data **sd, int *index); +typedef int (*HPMHOOK_post_pet_equipitem) (int retVal___, struct map_session_data *sd, int index); +typedef int (*HPMHOOK_pre_pet_randomwalk) (struct pet_data **pd, int64 *tick); +typedef int (*HPMHOOK_post_pet_randomwalk) (int retVal___, struct pet_data *pd, int64 tick); +typedef int (*HPMHOOK_pre_pet_ai_sub_hard) (struct pet_data **pd, struct map_session_data **sd, int64 *tick); +typedef int (*HPMHOOK_post_pet_ai_sub_hard) (int retVal___, struct pet_data *pd, struct map_session_data *sd, int64 tick); +typedef int (*HPMHOOK_pre_pet_ai_sub_foreachclient) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_pet_ai_sub_foreachclient) (int retVal___, struct map_session_data *sd, va_list ap); +typedef int (*HPMHOOK_pre_pet_ai_hard) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_ai_hard) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_delay_item_drop) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_delay_item_drop) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_lootitem_drop) (struct pet_data **pd, struct map_session_data **sd); +typedef int (*HPMHOOK_post_pet_lootitem_drop) (int retVal___, struct pet_data *pd, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_pet_skill_bonus_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_skill_bonus_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_recovery_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_recovery_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_skill_support_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_pet_skill_support_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_pet_read_db) (void); +typedef int (*HPMHOOK_post_pet_read_db) (int retVal___); +#endif // MAP_PET_H +#ifdef CHAR_PINCODE_H /* pincode */ +typedef void (*HPMHOOK_pre_pincode_handle) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_pincode_handle) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_pincode_decrypt) (unsigned int *userSeed, char **pin); +typedef void (*HPMHOOK_post_pincode_decrypt) (unsigned int userSeed, char *pin); +typedef void (*HPMHOOK_pre_pincode_error) (int *account_id); +typedef void (*HPMHOOK_post_pincode_error) (int account_id); +typedef void (*HPMHOOK_pre_pincode_update) (int *account_id, char **pin); +typedef void (*HPMHOOK_post_pincode_update) (int account_id, char *pin); +typedef void (*HPMHOOK_pre_pincode_sendstate) (int *fd, struct char_session_data **sd, uint16 *state); +typedef void (*HPMHOOK_post_pincode_sendstate) (int fd, struct char_session_data *sd, uint16 state); +typedef void (*HPMHOOK_pre_pincode_setnew) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_pincode_setnew) (int fd, struct char_session_data *sd); +typedef void (*HPMHOOK_pre_pincode_change) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_pincode_change) (int fd, struct char_session_data *sd); +typedef int (*HPMHOOK_pre_pincode_compare) (int *fd, struct char_session_data **sd, char **pin); +typedef int (*HPMHOOK_post_pincode_compare) (int retVal___, int fd, struct char_session_data *sd, char *pin); +typedef void (*HPMHOOK_pre_pincode_check) (int *fd, struct char_session_data **sd); +typedef void (*HPMHOOK_post_pincode_check) (int fd, struct char_session_data *sd); +typedef bool (*HPMHOOK_pre_pincode_config_read) (char **w1, char **w2); +typedef bool (*HPMHOOK_post_pincode_config_read) (bool retVal___, char *w1, char *w2); +#endif // CHAR_PINCODE_H +#ifdef MAP_QUEST_H /* quest */ +typedef void (*HPMHOOK_pre_quest_init) (bool *minimal); +typedef void (*HPMHOOK_post_quest_init) (bool minimal); +typedef void (*HPMHOOK_pre_quest_final) (void); +typedef void (*HPMHOOK_post_quest_final) (void); +typedef void (*HPMHOOK_pre_quest_reload) (void); +typedef void (*HPMHOOK_post_quest_reload) (void); +typedef struct quest_db* (*HPMHOOK_pre_quest_db) (int *quest_id); +typedef struct quest_db* (*HPMHOOK_post_quest_db) (struct quest_db* retVal___, int quest_id); +typedef int (*HPMHOOK_pre_quest_pc_login) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_quest_pc_login) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_quest_add) (struct map_session_data **sd, int *quest_id); +typedef int (*HPMHOOK_post_quest_add) (int retVal___, struct map_session_data *sd, int quest_id); +typedef int (*HPMHOOK_pre_quest_change) (struct map_session_data **sd, int *qid1, int *qid2); +typedef int (*HPMHOOK_post_quest_change) (int retVal___, struct map_session_data *sd, int qid1, int qid2); +typedef int (*HPMHOOK_pre_quest_delete) (struct map_session_data **sd, int *quest_id); +typedef int (*HPMHOOK_post_quest_delete) (int retVal___, struct map_session_data *sd, int quest_id); +typedef int (*HPMHOOK_pre_quest_update_objective_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_quest_update_objective_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_quest_update_objective) (struct map_session_data **sd, int *mob_id); +typedef void (*HPMHOOK_post_quest_update_objective) (struct map_session_data *sd, int mob_id); +typedef int (*HPMHOOK_pre_quest_update_status) (struct map_session_data **sd, int *quest_id, enum quest_state *qs); +typedef int (*HPMHOOK_post_quest_update_status) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_state qs); +typedef int (*HPMHOOK_pre_quest_check) (struct map_session_data **sd, int *quest_id, enum quest_check_type *type); +typedef int (*HPMHOOK_post_quest_check) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_check_type type); +typedef void (*HPMHOOK_pre_quest_clear) (void); +typedef void (*HPMHOOK_post_quest_clear) (void); +typedef int (*HPMHOOK_pre_quest_read_db) (void); +typedef int (*HPMHOOK_post_quest_read_db) (int retVal___); +typedef struct quest_db* (*HPMHOOK_pre_quest_read_db_sub) (struct config_setting_t **cs, int *n, const char **source); +typedef struct quest_db* (*HPMHOOK_post_quest_read_db_sub) (struct quest_db* retVal___, struct config_setting_t *cs, int n, const char *source); +#endif // MAP_QUEST_H +#ifdef MAP_SCRIPT_H /* script */ +typedef void (*HPMHOOK_pre_script_init) (bool *minimal); +typedef void (*HPMHOOK_post_script_init) (bool minimal); +typedef void (*HPMHOOK_pre_script_final) (void); +typedef void (*HPMHOOK_post_script_final) (void); +typedef int (*HPMHOOK_pre_script_reload) (void); +typedef int (*HPMHOOK_post_script_reload) (int retVal___); +typedef struct script_code* (*HPMHOOK_pre_script_parse) (const char **src, const char **file, int *line, int *options, int **retval); +typedef struct script_code* (*HPMHOOK_post_script_parse) (struct script_code* retVal___, const char *src, const char *file, int line, int options, int *retval); +typedef bool (*HPMHOOK_pre_script_add_builtin) (const struct script_function **buildin, bool *override); +typedef bool (*HPMHOOK_post_script_add_builtin) (bool retVal___, const struct script_function *buildin, bool override); +typedef void (*HPMHOOK_pre_script_parse_builtin) (void); +typedef void (*HPMHOOK_post_script_parse_builtin) (void); +typedef const char* (*HPMHOOK_pre_script_parse_subexpr) (const char **p, int *limit); +typedef const char* (*HPMHOOK_post_script_parse_subexpr) (const char* retVal___, const char *p, int limit); +typedef const char* (*HPMHOOK_pre_script_skip_space) (const char **p); +typedef const char* (*HPMHOOK_post_script_skip_space) (const char* retVal___, const char *p); +typedef void (*HPMHOOK_pre_script_error) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); +typedef void (*HPMHOOK_post_script_error) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); +typedef void (*HPMHOOK_pre_script_warning) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); +typedef void (*HPMHOOK_post_script_warning) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); +typedef bool (*HPMHOOK_pre_script_addScript) (char **name, char **args, bool ( **func ) (struct script_state *st), bool *isDeprecated); +typedef bool (*HPMHOOK_post_script_addScript) (bool retVal___, char *name, char *args, bool ( *func ) (struct script_state *st), bool isDeprecated); +typedef int (*HPMHOOK_pre_script_conv_num) (struct script_state **st, struct script_data **data); +typedef int (*HPMHOOK_post_script_conv_num) (int retVal___, struct script_state *st, struct script_data *data); +typedef const char* (*HPMHOOK_pre_script_conv_str) (struct script_state **st, struct script_data **data); +typedef const char* (*HPMHOOK_post_script_conv_str) (const char* retVal___, struct script_state *st, struct script_data *data); +typedef struct map_session_data* (*HPMHOOK_pre_script_rid2sd) (struct script_state **st); +typedef struct map_session_data* (*HPMHOOK_post_script_rid2sd) (struct map_session_data* retVal___, struct script_state *st); +typedef struct map_session_data* (*HPMHOOK_pre_script_id2sd) (struct script_state **st, int *account_id); +typedef struct map_session_data* (*HPMHOOK_post_script_id2sd) (struct map_session_data* retVal___, struct script_state *st, int account_id); +typedef struct map_session_data* (*HPMHOOK_pre_script_charid2sd) (struct script_state **st, int *char_id); +typedef struct map_session_data* (*HPMHOOK_post_script_charid2sd) (struct map_session_data* retVal___, struct script_state *st, int char_id); +typedef struct map_session_data* (*HPMHOOK_pre_script_nick2sd) (struct script_state **st, const char **name); +typedef struct map_session_data* (*HPMHOOK_post_script_nick2sd) (struct map_session_data* retVal___, struct script_state *st, const char *name); +typedef void (*HPMHOOK_pre_script_detach_rid) (struct script_state **st); +typedef void (*HPMHOOK_post_script_detach_rid) (struct script_state *st); +typedef struct script_data* (*HPMHOOK_pre_script_push_val) (struct script_stack **stack, enum c_op *type, int64 *val, struct reg_db **ref); +typedef struct script_data* (*HPMHOOK_post_script_push_val) (struct script_data* retVal___, struct script_stack *stack, enum c_op type, int64 val, struct reg_db *ref); +typedef struct script_data* (*HPMHOOK_pre_script_get_val) (struct script_state **st, struct script_data **data); +typedef struct script_data* (*HPMHOOK_post_script_get_val) (struct script_data* retVal___, struct script_state *st, struct script_data *data); +typedef char* (*HPMHOOK_pre_script_get_val_ref_str) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef char* (*HPMHOOK_post_script_get_val_ref_str) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef char* (*HPMHOOK_pre_script_get_val_scope_str) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef char* (*HPMHOOK_post_script_get_val_scope_str) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef char* (*HPMHOOK_pre_script_get_val_npc_str) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef char* (*HPMHOOK_post_script_get_val_npc_str) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef char* (*HPMHOOK_pre_script_get_val_instance_str) (struct script_state **st, const char **name, struct script_data **data); +typedef char* (*HPMHOOK_post_script_get_val_instance_str) (char* retVal___, struct script_state *st, const char *name, struct script_data *data); +typedef int (*HPMHOOK_pre_script_get_val_ref_num) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef int (*HPMHOOK_post_script_get_val_ref_num) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef int (*HPMHOOK_pre_script_get_val_scope_num) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef int (*HPMHOOK_post_script_get_val_scope_num) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef int (*HPMHOOK_pre_script_get_val_npc_num) (struct script_state **st, struct reg_db **n, struct script_data **data); +typedef int (*HPMHOOK_post_script_get_val_npc_num) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data); +typedef int (*HPMHOOK_pre_script_get_val_instance_num) (struct script_state **st, const char **name, struct script_data **data); +typedef int (*HPMHOOK_post_script_get_val_instance_num) (int retVal___, struct script_state *st, const char *name, struct script_data *data); +typedef const void* (*HPMHOOK_pre_script_get_val2) (struct script_state **st, int64 *uid, struct reg_db **ref); +typedef const void* (*HPMHOOK_post_script_get_val2) (const void* retVal___, struct script_state *st, int64 uid, struct reg_db *ref); +typedef struct script_data* (*HPMHOOK_pre_script_push_str) (struct script_stack **stack, char **str); +typedef struct script_data* (*HPMHOOK_post_script_push_str) (struct script_data* retVal___, struct script_stack *stack, char *str); +typedef struct script_data* (*HPMHOOK_pre_script_push_conststr) (struct script_stack **stack, const char **str); +typedef struct script_data* (*HPMHOOK_post_script_push_conststr) (struct script_data* retVal___, struct script_stack *stack, const char *str); +typedef struct script_data* (*HPMHOOK_pre_script_push_copy) (struct script_stack **stack, int *pos); +typedef struct script_data* (*HPMHOOK_post_script_push_copy) (struct script_data* retVal___, struct script_stack *stack, int pos); +typedef void (*HPMHOOK_pre_script_pop_stack) (struct script_state **st, int *start, int *end); +typedef void (*HPMHOOK_post_script_pop_stack) (struct script_state *st, int start, int end); +typedef void (*HPMHOOK_pre_script_set_constant) (const char **name, int *value, bool *is_parameter, bool *is_deprecated); +typedef void (*HPMHOOK_post_script_set_constant) (const char *name, int value, bool is_parameter, bool is_deprecated); +typedef void (*HPMHOOK_pre_script_set_constant2) (const char **name, int *value, bool *is_parameter, bool *is_deprecated); +typedef void (*HPMHOOK_post_script_set_constant2) (const char *name, int value, bool is_parameter, bool is_deprecated); +typedef bool (*HPMHOOK_pre_script_get_constant) (const char **name, int **value); +typedef bool (*HPMHOOK_post_script_get_constant) (bool retVal___, const char *name, int *value); +typedef void (*HPMHOOK_pre_script_label_add) (int *key, int *pos); +typedef void (*HPMHOOK_post_script_label_add) (int key, int pos); +typedef void (*HPMHOOK_pre_script_run) (struct script_code **rootscript, int *pos, int *rid, int *oid); +typedef void (*HPMHOOK_post_script_run) (struct script_code *rootscript, int pos, int rid, int oid); +typedef void (*HPMHOOK_pre_script_run_npc) (struct script_code **rootscript, int *pos, int *rid, int *oid); +typedef void (*HPMHOOK_post_script_run_npc) (struct script_code *rootscript, int pos, int rid, int oid); +typedef void (*HPMHOOK_pre_script_run_pet) (struct script_code **rootscript, int *pos, int *rid, int *oid); +typedef void (*HPMHOOK_post_script_run_pet) (struct script_code *rootscript, int pos, int rid, int oid); +typedef void (*HPMHOOK_pre_script_run_main) (struct script_state **st); +typedef void (*HPMHOOK_post_script_run_main) (struct script_state *st); +typedef int (*HPMHOOK_pre_script_run_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_script_run_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_script_set_var) (struct map_session_data **sd, char **name, void **val); +typedef int (*HPMHOOK_post_script_set_var) (int retVal___, struct map_session_data *sd, char *name, void *val); +typedef void (*HPMHOOK_pre_script_stop_instances) (struct script_code **code); +typedef void (*HPMHOOK_post_script_stop_instances) (struct script_code *code); +typedef void (*HPMHOOK_pre_script_free_code) (struct script_code **code); +typedef void (*HPMHOOK_post_script_free_code) (struct script_code *code); +typedef void (*HPMHOOK_pre_script_free_vars) (struct DBMap **var_storage); +typedef void (*HPMHOOK_post_script_free_vars) (struct DBMap *var_storage); +typedef struct script_state* (*HPMHOOK_pre_script_alloc_state) (struct script_code **rootscript, int *pos, int *rid, int *oid); +typedef struct script_state* (*HPMHOOK_post_script_alloc_state) (struct script_state* retVal___, struct script_code *rootscript, int pos, int rid, int oid); +typedef void (*HPMHOOK_pre_script_free_state) (struct script_state **st); +typedef void (*HPMHOOK_post_script_free_state) (struct script_state *st); +typedef void (*HPMHOOK_pre_script_add_pending_ref) (struct script_state **st, struct reg_db **ref); +typedef void (*HPMHOOK_post_script_add_pending_ref) (struct script_state *st, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_run_autobonus) (const char **autobonus, int *id, int *pos); +typedef void (*HPMHOOK_post_script_run_autobonus) (const char *autobonus, int id, int pos); +typedef void (*HPMHOOK_pre_script_cleararray_pc) (struct map_session_data **sd, const char **varname, void **value); +typedef void (*HPMHOOK_post_script_cleararray_pc) (struct map_session_data *sd, const char *varname, void *value); +typedef void (*HPMHOOK_pre_script_setarray_pc) (struct map_session_data **sd, const char **varname, uint32 *idx, void **value, int **refcache); +typedef void (*HPMHOOK_post_script_setarray_pc) (struct map_session_data *sd, const char *varname, uint32 idx, void *value, int *refcache); +typedef int (*HPMHOOK_pre_script_config_read) (char **cfgName); +typedef int (*HPMHOOK_post_script_config_read) (int retVal___, char *cfgName); +typedef int (*HPMHOOK_pre_script_add_str) (const char **p); +typedef int (*HPMHOOK_post_script_add_str) (int retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_get_str) (int *id); +typedef const char* (*HPMHOOK_post_script_get_str) (const char* retVal___, int id); +typedef int (*HPMHOOK_pre_script_search_str) (const char **p); +typedef int (*HPMHOOK_post_script_search_str) (int retVal___, const char *p); +typedef void (*HPMHOOK_pre_script_setd_sub) (struct script_state **st, struct map_session_data **sd, const char **varname, int *elem, const void **value, struct reg_db **ref); +typedef void (*HPMHOOK_post_script_setd_sub) (struct script_state *st, struct map_session_data *sd, const char *varname, int elem, const void *value, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_attach_state) (struct script_state **st); +typedef void (*HPMHOOK_post_script_attach_state) (struct script_state *st); +typedef struct script_queue* (*HPMHOOK_pre_script_queue) (int *idx); +typedef struct script_queue* (*HPMHOOK_post_script_queue) (struct script_queue* retVal___, int idx); +typedef bool (*HPMHOOK_pre_script_queue_add) (int *idx, int *var); +typedef bool (*HPMHOOK_post_script_queue_add) (bool retVal___, int idx, int var); +typedef bool (*HPMHOOK_pre_script_queue_del) (int *idx); +typedef bool (*HPMHOOK_post_script_queue_del) (bool retVal___, int idx); +typedef bool (*HPMHOOK_pre_script_queue_remove) (int *idx, int *var); +typedef bool (*HPMHOOK_post_script_queue_remove) (bool retVal___, int idx, int var); +typedef int (*HPMHOOK_pre_script_queue_create) (void); +typedef int (*HPMHOOK_post_script_queue_create) (int retVal___); +typedef bool (*HPMHOOK_pre_script_queue_clear) (int *idx); +typedef bool (*HPMHOOK_post_script_queue_clear) (bool retVal___, int idx); +typedef const char* (*HPMHOOK_pre_script_parse_curly_close) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_curly_close) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_syntax_close) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_syntax_close) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_syntax_close_sub) (const char **p, int **flag); +typedef const char* (*HPMHOOK_post_script_parse_syntax_close_sub) (const char* retVal___, const char *p, int *flag); +typedef const char* (*HPMHOOK_pre_script_parse_syntax) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_syntax) (const char* retVal___, const char *p); +typedef c_op (*HPMHOOK_pre_script_get_com) (const struct script_buf **scriptbuf, int **pos); +typedef c_op (*HPMHOOK_post_script_get_com) (c_op retVal___, const struct script_buf *scriptbuf, int *pos); +typedef int (*HPMHOOK_pre_script_get_num) (const struct script_buf **scriptbuf, int **pos); +typedef int (*HPMHOOK_post_script_get_num) (int retVal___, const struct script_buf *scriptbuf, int *pos); +typedef const char* (*HPMHOOK_pre_script_op2name) (int *op); +typedef const char* (*HPMHOOK_post_script_op2name) (const char* retVal___, int op); +typedef void (*HPMHOOK_pre_script_reportsrc) (struct script_state **st); +typedef void (*HPMHOOK_post_script_reportsrc) (struct script_state *st); +typedef void (*HPMHOOK_pre_script_reportdata) (struct script_data **data); +typedef void (*HPMHOOK_post_script_reportdata) (struct script_data *data); +typedef void (*HPMHOOK_pre_script_reportfunc) (struct script_state **st); +typedef void (*HPMHOOK_post_script_reportfunc) (struct script_state *st); +typedef void (*HPMHOOK_pre_script_disp_warning_message) (const char **mes, const char **pos); +typedef void (*HPMHOOK_post_script_disp_warning_message) (const char *mes, const char *pos); +typedef void (*HPMHOOK_pre_script_check_event) (struct script_state **st, const char **evt); +typedef void (*HPMHOOK_post_script_check_event) (struct script_state *st, const char *evt); +typedef unsigned int (*HPMHOOK_pre_script_calc_hash) (const char **p); +typedef unsigned int (*HPMHOOK_post_script_calc_hash) (unsigned int retVal___, const char *p); +typedef void (*HPMHOOK_pre_script_addb) (int *a); +typedef void (*HPMHOOK_post_script_addb) (int a); +typedef void (*HPMHOOK_pre_script_addc) (int *a); +typedef void (*HPMHOOK_post_script_addc) (int a); +typedef void (*HPMHOOK_pre_script_addi) (int *a); +typedef void (*HPMHOOK_post_script_addi) (int a); +typedef void (*HPMHOOK_pre_script_addl) (int *l); +typedef void (*HPMHOOK_post_script_addl) (int l); +typedef void (*HPMHOOK_pre_script_set_label) (int *l, int *pos, const char **script_pos); +typedef void (*HPMHOOK_post_script_set_label) (int l, int pos, const char *script_pos); +typedef const char* (*HPMHOOK_pre_script_skip_word) (const char **p); +typedef const char* (*HPMHOOK_post_script_skip_word) (const char* retVal___, const char *p); +typedef int (*HPMHOOK_pre_script_add_word) (const char **p); +typedef int (*HPMHOOK_post_script_add_word) (int retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_callfunc) (const char **p, int *require_paren, int *is_custom); +typedef const char* (*HPMHOOK_post_script_parse_callfunc) (const char* retVal___, const char *p, int require_paren, int is_custom); +typedef void (*HPMHOOK_pre_script_parse_nextline) (bool *first, const char **p); +typedef void (*HPMHOOK_post_script_parse_nextline) (bool first, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_variable) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_variable) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_simpleexpr) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_simpleexpr) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_simpleexpr_paren) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_simpleexpr_paren) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_simpleexpr_number) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_simpleexpr_number) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_simpleexpr_string) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_simpleexpr_string) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_simpleexpr_name) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_simpleexpr_name) (const char* retVal___, const char *p); +typedef void (*HPMHOOK_pre_script_add_translatable_string) (const struct script_string_buf **string, const char **start_point); +typedef void (*HPMHOOK_post_script_add_translatable_string) (const struct script_string_buf *string, const char *start_point); +typedef const char* (*HPMHOOK_pre_script_parse_expr) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_expr) (const char* retVal___, const char *p); +typedef const char* (*HPMHOOK_pre_script_parse_line) (const char **p); +typedef const char* (*HPMHOOK_post_script_parse_line) (const char* retVal___, const char *p); +typedef void (*HPMHOOK_pre_script_read_constdb) (void); +typedef void (*HPMHOOK_post_script_read_constdb) (void); +typedef void (*HPMHOOK_pre_script_constdb_comment) (const char **comment); +typedef void (*HPMHOOK_post_script_constdb_comment) (const char *comment); +typedef void (*HPMHOOK_pre_script_load_parameters) (void); +typedef void (*HPMHOOK_post_script_load_parameters) (void); +typedef const char* (*HPMHOOK_pre_script_print_line) (StringBuf **buf, const char **p, const char **mark, int *line); +typedef const char* (*HPMHOOK_post_script_print_line) (const char* retVal___, StringBuf *buf, const char *p, const char *mark, int line); +typedef void (*HPMHOOK_pre_script_errorwarning_sub) (StringBuf **buf, const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); +typedef void (*HPMHOOK_post_script_errorwarning_sub) (StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); +typedef int (*HPMHOOK_pre_script_set_reg) (struct script_state **st, struct map_session_data **sd, int64 *num, const char **name, const void **value, struct reg_db **ref); +typedef int (*HPMHOOK_post_script_set_reg) (int retVal___, struct script_state *st, struct map_session_data *sd, int64 num, const char *name, const void *value, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_set_reg_ref_str) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); +typedef void (*HPMHOOK_post_script_set_reg_ref_str) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); +typedef void (*HPMHOOK_pre_script_set_reg_scope_str) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); +typedef void (*HPMHOOK_post_script_set_reg_scope_str) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); +typedef void (*HPMHOOK_pre_script_set_reg_npc_str) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); +typedef void (*HPMHOOK_post_script_set_reg_npc_str) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); +typedef void (*HPMHOOK_pre_script_set_reg_instance_str) (struct script_state **st, int64 *num, const char **name, const char **str); +typedef void (*HPMHOOK_post_script_set_reg_instance_str) (struct script_state *st, int64 num, const char *name, const char *str); +typedef void (*HPMHOOK_pre_script_set_reg_ref_num) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); +typedef void (*HPMHOOK_post_script_set_reg_ref_num) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); +typedef void (*HPMHOOK_pre_script_set_reg_scope_num) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); +typedef void (*HPMHOOK_post_script_set_reg_scope_num) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); +typedef void (*HPMHOOK_pre_script_set_reg_npc_num) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); +typedef void (*HPMHOOK_post_script_set_reg_npc_num) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); +typedef void (*HPMHOOK_pre_script_set_reg_instance_num) (struct script_state **st, int64 *num, const char **name, int *val); +typedef void (*HPMHOOK_post_script_set_reg_instance_num) (struct script_state *st, int64 num, const char *name, int val); +typedef void (*HPMHOOK_pre_script_stack_expand) (struct script_stack **stack); +typedef void (*HPMHOOK_post_script_stack_expand) (struct script_stack *stack); +typedef struct script_data* (*HPMHOOK_pre_script_push_retinfo) (struct script_stack **stack, struct script_retinfo **ri, struct reg_db **ref); +typedef struct script_data* (*HPMHOOK_post_script_push_retinfo) (struct script_data* retVal___, struct script_stack *stack, struct script_retinfo *ri, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_op_3) (struct script_state **st, int *op); +typedef void (*HPMHOOK_post_script_op_3) (struct script_state *st, int op); +typedef void (*HPMHOOK_pre_script_op_2str) (struct script_state **st, int *op, const char **s1, const char **s2); +typedef void (*HPMHOOK_post_script_op_2str) (struct script_state *st, int op, const char *s1, const char *s2); +typedef void (*HPMHOOK_pre_script_op_2num) (struct script_state **st, int *op, int *i1, int *i2); +typedef void (*HPMHOOK_post_script_op_2num) (struct script_state *st, int op, int i1, int i2); +typedef void (*HPMHOOK_pre_script_op_2) (struct script_state **st, int *op); +typedef void (*HPMHOOK_post_script_op_2) (struct script_state *st, int op); +typedef void (*HPMHOOK_pre_script_op_1) (struct script_state **st, int *op); +typedef void (*HPMHOOK_post_script_op_1) (struct script_state *st, int op); +typedef bool (*HPMHOOK_pre_script_check_buildin_argtype) (struct script_state **st, int *func); +typedef bool (*HPMHOOK_post_script_check_buildin_argtype) (bool retVal___, struct script_state *st, int func); +typedef void (*HPMHOOK_pre_script_detach_state) (struct script_state **st, bool *dequeue_event); +typedef void (*HPMHOOK_post_script_detach_state) (struct script_state *st, bool dequeue_event); +typedef int (*HPMHOOK_pre_script_db_free_code_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_script_db_free_code_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_script_add_autobonus) (const char **autobonus); +typedef void (*HPMHOOK_post_script_add_autobonus) (const char *autobonus); +typedef int (*HPMHOOK_pre_script_menu_countoptions) (const char **str, int *max_count, int **total); +typedef int (*HPMHOOK_post_script_menu_countoptions) (int retVal___, const char *str, int max_count, int *total); +typedef int (*HPMHOOK_pre_script_buildin_areawarp_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_areawarp_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_areapercentheal_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_areapercentheal_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_script_buildin_delitem_delete) (struct map_session_data **sd, int *idx, int **amount, bool *delete_items); +typedef void (*HPMHOOK_post_script_buildin_delitem_delete) (struct map_session_data *sd, int idx, int *amount, bool delete_items); +typedef bool (*HPMHOOK_pre_script_buildin_delitem_search) (struct map_session_data **sd, struct item **it, bool *exact_match); +typedef bool (*HPMHOOK_post_script_buildin_delitem_search) (bool retVal___, struct map_session_data *sd, struct item *it, bool exact_match); +typedef int (*HPMHOOK_pre_script_buildin_killmonster_sub_strip) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_killmonster_sub_strip) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_killmonster_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_killmonster_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_killmonsterall_sub_strip) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_killmonsterall_sub_strip) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_killmonsterall_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_killmonsterall_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_announce_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_announce_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_getareausers_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_getareausers_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_getareadropitem_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_getareadropitem_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_mapflag_pvp_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_mapflag_pvp_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_pvpoff_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_pvpoff_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_maprespawnguildid_sub_pc) (struct map_session_data **sd, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_maprespawnguildid_sub_pc) (int retVal___, struct map_session_data *sd, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_maprespawnguildid_sub_mob) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_maprespawnguildid_sub_mob) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_mobcount_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_mobcount_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_playbgm_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_playbgm_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_playbgm_foreachpc_sub) (struct map_session_data **sd, va_list args); +typedef int (*HPMHOOK_post_script_playbgm_foreachpc_sub) (int retVal___, struct map_session_data *sd, va_list args); +typedef int (*HPMHOOK_pre_script_soundeffect_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_soundeffect_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_query_sql_sub) (struct script_state **st, struct Sql **handle); +typedef int (*HPMHOOK_post_script_buildin_query_sql_sub) (int retVal___, struct script_state *st, struct Sql *handle); +typedef int (*HPMHOOK_pre_script_buildin_instance_warpall_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_instance_warpall_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_buildin_mobuseskill_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_buildin_mobuseskill_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_cleanfloor_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_script_cleanfloor_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_script_run_func) (struct script_state **st); +typedef int (*HPMHOOK_post_script_run_func) (int retVal___, struct script_state *st); +typedef const char* (*HPMHOOK_pre_script_getfuncname) (struct script_state **st); +typedef const char* (*HPMHOOK_post_script_getfuncname) (const char* retVal___, struct script_state *st); +typedef unsigned int (*HPMHOOK_pre_script_calc_hash_ci) (const char **p); +typedef unsigned int (*HPMHOOK_post_script_calc_hash_ci) (unsigned int retVal___, const char *p); +typedef struct reg_db* (*HPMHOOK_pre_script_array_src) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); +typedef struct reg_db* (*HPMHOOK_post_script_array_src) (struct reg_db* retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_array_update) (struct reg_db **src, int64 *num, bool *empty); +typedef void (*HPMHOOK_post_script_array_update) (struct reg_db *src, int64 num, bool empty); +typedef void (*HPMHOOK_pre_script_array_delete) (struct reg_db **src, struct script_array **sa); +typedef void (*HPMHOOK_post_script_array_delete) (struct reg_db *src, struct script_array *sa); +typedef void (*HPMHOOK_pre_script_array_remove_member) (struct reg_db **src, struct script_array **sa, unsigned int *idx); +typedef void (*HPMHOOK_post_script_array_remove_member) (struct reg_db *src, struct script_array *sa, unsigned int idx); +typedef void (*HPMHOOK_pre_script_array_add_member) (struct script_array **sa, unsigned int *idx); +typedef void (*HPMHOOK_post_script_array_add_member) (struct script_array *sa, unsigned int idx); +typedef unsigned int (*HPMHOOK_pre_script_array_size) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); +typedef unsigned int (*HPMHOOK_post_script_array_size) (unsigned int retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); +typedef unsigned int (*HPMHOOK_pre_script_array_highest_key) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); +typedef unsigned int (*HPMHOOK_post_script_array_highest_key) (unsigned int retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); +typedef int (*HPMHOOK_pre_script_array_free_db) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_script_array_free_db) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_script_array_ensure_zero) (struct script_state **st, struct map_session_data **sd, int64 *uid, struct reg_db **ref); +typedef void (*HPMHOOK_post_script_array_ensure_zero) (struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref); +typedef void (*HPMHOOK_pre_script_reg_destroy_single) (struct map_session_data **sd, int64 *reg, struct script_reg_state **data); +typedef void (*HPMHOOK_post_script_reg_destroy_single) (struct map_session_data *sd, int64 reg, struct script_reg_state *data); +typedef int (*HPMHOOK_pre_script_reg_destroy) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_script_reg_destroy) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_script_generic_ui_array_expand) (unsigned int *plus); +typedef void (*HPMHOOK_post_script_generic_ui_array_expand) (unsigned int plus); +typedef unsigned int* (*HPMHOOK_pre_script_array_cpy_list) (struct script_array **sa); +typedef unsigned int* (*HPMHOOK_post_script_array_cpy_list) (unsigned int* retVal___, struct script_array *sa); +typedef void (*HPMHOOK_pre_script_hardcoded_constants) (void); +typedef void (*HPMHOOK_post_script_hardcoded_constants) (void); +typedef unsigned short (*HPMHOOK_pre_script_mapindexname2id) (struct script_state **st, const char **name); +typedef unsigned short (*HPMHOOK_post_script_mapindexname2id) (unsigned short retVal___, struct script_state *st, const char *name); +typedef int (*HPMHOOK_pre_script_string_dup) (char **str); +typedef int (*HPMHOOK_post_script_string_dup) (int retVal___, char *str); +typedef void (*HPMHOOK_pre_script_load_translations) (void); +typedef void (*HPMHOOK_post_script_load_translations) (void); +typedef int (*HPMHOOK_pre_script_load_translation) (const char **file, uint8 *lang_id); +typedef int (*HPMHOOK_post_script_load_translation) (int retVal___, const char *file, uint8 lang_id); +typedef int (*HPMHOOK_pre_script_translation_db_destroyer) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_script_translation_db_destroyer) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_script_clear_translations) (bool *reload); +typedef void (*HPMHOOK_post_script_clear_translations) (bool reload); +typedef int (*HPMHOOK_pre_script_parse_cleanup_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_script_parse_cleanup_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef uint8 (*HPMHOOK_pre_script_add_language) (const char **name); +typedef uint8 (*HPMHOOK_post_script_add_language) (uint8 retVal___, const char *name); +typedef const char* (*HPMHOOK_pre_script_get_translation_file_name) (const char **file); +typedef const char* (*HPMHOOK_post_script_get_translation_file_name) (const char* retVal___, const char *file); +typedef void (*HPMHOOK_pre_script_parser_clean_leftovers) (void); +typedef void (*HPMHOOK_post_script_parser_clean_leftovers) (void); +typedef void (*HPMHOOK_pre_script_run_use_script) (struct map_session_data **sd, struct item_data **data, int *oid); +typedef void (*HPMHOOK_post_script_run_use_script) (struct map_session_data *sd, struct item_data *data, int oid); +typedef void (*HPMHOOK_pre_script_run_item_equip_script) (struct map_session_data **sd, struct item_data **data, int *oid); +typedef void (*HPMHOOK_post_script_run_item_equip_script) (struct map_session_data *sd, struct item_data *data, int oid); +typedef void (*HPMHOOK_pre_script_run_item_unequip_script) (struct map_session_data **sd, struct item_data **data, int *oid); +typedef void (*HPMHOOK_post_script_run_item_unequip_script) (struct map_session_data *sd, struct item_data *data, int oid); +#endif // MAP_SCRIPT_H +#ifdef MAP_SEARCHSTORE_H /* searchstore */ +typedef bool (*HPMHOOK_pre_searchstore_open) (struct map_session_data **sd, unsigned int *uses, unsigned short *effect); +typedef bool (*HPMHOOK_post_searchstore_open) (bool retVal___, struct map_session_data *sd, unsigned int uses, unsigned short effect); +typedef void (*HPMHOOK_pre_searchstore_query) (struct map_session_data **sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short **itemlist, unsigned int *item_count, const unsigned short **cardlist, unsigned int *card_count); +typedef void (*HPMHOOK_post_searchstore_query) (struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count); +typedef bool (*HPMHOOK_pre_searchstore_querynext) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_searchstore_querynext) (bool retVal___, struct map_session_data *sd); +typedef void (*HPMHOOK_pre_searchstore_next) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_searchstore_next) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_searchstore_clear) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_searchstore_clear) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_searchstore_close) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_searchstore_close) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_searchstore_click) (struct map_session_data **sd, int *account_id, int *store_id, unsigned short *nameid); +typedef void (*HPMHOOK_post_searchstore_click) (struct map_session_data *sd, int account_id, int store_id, unsigned short nameid); +typedef bool (*HPMHOOK_pre_searchstore_queryremote) (struct map_session_data **sd, int *account_id); +typedef bool (*HPMHOOK_post_searchstore_queryremote) (bool retVal___, struct map_session_data *sd, int account_id); +typedef void (*HPMHOOK_pre_searchstore_clearremote) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_searchstore_clearremote) (struct map_session_data *sd); +typedef bool (*HPMHOOK_pre_searchstore_result) (struct map_session_data **sd, unsigned int *store_id, int *account_id, const char **store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short **card, unsigned char *refine); +typedef bool (*HPMHOOK_post_searchstore_result) (bool retVal___, struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, unsigned short nameid, unsigned short amount, unsigned int price, const short *card, unsigned char refine); +#endif // MAP_SEARCHSTORE_H +#ifdef COMMON_SHOWMSG_H /* showmsg */ +typedef void (*HPMHOOK_pre_showmsg_init) (void); +typedef void (*HPMHOOK_post_showmsg_init) (void); +typedef void (*HPMHOOK_pre_showmsg_final) (void); +typedef void (*HPMHOOK_post_showmsg_final) (void); +typedef void (*HPMHOOK_pre_showmsg_clearScreen) (void); +typedef void (*HPMHOOK_post_showmsg_clearScreen) (void); +typedef int (*HPMHOOK_pre_showmsg_showMessageV) (const char **string, va_list ap); +typedef int (*HPMHOOK_post_showmsg_showMessageV) (int retVal___, const char *string, va_list ap); +#endif // COMMON_SHOWMSG_H +#ifdef MAP_SKILL_H /* skill */ +typedef int (*HPMHOOK_pre_skill_init) (bool *minimal); +typedef int (*HPMHOOK_post_skill_init) (int retVal___, bool minimal); +typedef int (*HPMHOOK_pre_skill_final) (void); +typedef int (*HPMHOOK_post_skill_final) (int retVal___); +typedef void (*HPMHOOK_pre_skill_reload) (void); +typedef void (*HPMHOOK_post_skill_reload) (void); +typedef void (*HPMHOOK_pre_skill_read_db) (bool *minimal); +typedef void (*HPMHOOK_post_skill_read_db) (bool minimal); +typedef int (*HPMHOOK_pre_skill_get_index) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_index) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_type) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_type) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_hit) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_hit) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_inf) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_inf) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_ele) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_ele) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_nk) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_nk) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_max) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_max) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_range) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_range) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_range2) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_range2) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_splash) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_splash) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_hp) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_hp) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_mhp) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_mhp) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_sp) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_sp) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_state) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_state) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_spiritball) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_spiritball) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_zeny) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_zeny) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_num) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_num) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_cast) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_cast) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_delay) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_delay) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_walkdelay) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_walkdelay) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_time) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_time) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_time2) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_time2) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_castnodex) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_castnodex) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_delaynodex) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_delaynodex) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_castdef) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_castdef) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_weapontype) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_weapontype) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_ammotype) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_ammotype) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_ammo_qty) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_ammo_qty) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_unit_id) (uint16 *skill_id, int *flag); +typedef int (*HPMHOOK_post_skill_get_unit_id) (int retVal___, uint16 skill_id, int flag); +typedef int (*HPMHOOK_pre_skill_get_inf2) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_inf2) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_castcancel) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_castcancel) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_maxcount) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_maxcount) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_blewcount) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_blewcount) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_unit_flag) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_unit_flag) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_unit_target) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_unit_target) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_unit_interval) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_unit_interval) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_unit_bl_target) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_unit_bl_target) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_unit_layout_type) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_unit_layout_type) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_unit_range) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_unit_range) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_get_cooldown) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_cooldown) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_tree_get_max) (uint16 *skill_id, int *b_class); +typedef int (*HPMHOOK_post_skill_tree_get_max) (int retVal___, uint16 skill_id, int b_class); +typedef const char* (*HPMHOOK_pre_skill_get_name) (uint16 *skill_id); +typedef const char* (*HPMHOOK_post_skill_get_name) (const char* retVal___, uint16 skill_id); +typedef const char* (*HPMHOOK_pre_skill_get_desc) (uint16 *skill_id); +typedef const char* (*HPMHOOK_post_skill_get_desc) (const char* retVal___, uint16 skill_id); +typedef void (*HPMHOOK_pre_skill_chk) (uint16 **skill_id); +typedef void (*HPMHOOK_post_skill_chk) (uint16 *skill_id); +typedef int (*HPMHOOK_pre_skill_get_casttype) (uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_get_casttype) (int retVal___, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_get_casttype2) (uint16 *index); +typedef int (*HPMHOOK_post_skill_get_casttype2) (int retVal___, uint16 index); +typedef bool (*HPMHOOK_pre_skill_is_combo) (int *skill_id); +typedef bool (*HPMHOOK_post_skill_is_combo) (bool retVal___, int skill_id); +typedef int (*HPMHOOK_pre_skill_name2id) (const char **name); +typedef int (*HPMHOOK_post_skill_name2id) (int retVal___, const char *name); +typedef int (*HPMHOOK_pre_skill_isammotype) (struct map_session_data **sd, int *skill_id); +typedef int (*HPMHOOK_post_skill_isammotype) (int retVal___, struct map_session_data *sd, int skill_id); +typedef int (*HPMHOOK_pre_skill_castend_id) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_castend_id) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_castend_pos) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_castend_pos) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_castend_map) (struct map_session_data **sd, uint16 *skill_id, const char **mapname); +typedef int (*HPMHOOK_post_skill_castend_map) (int retVal___, struct map_session_data *sd, uint16 skill_id, const char *mapname); +typedef int (*HPMHOOK_pre_skill_cleartimerskill) (struct block_list **src); +typedef int (*HPMHOOK_post_skill_cleartimerskill) (int retVal___, struct block_list *src); +typedef int (*HPMHOOK_pre_skill_addtimerskill) (struct block_list **src, int64 *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag); +typedef int (*HPMHOOK_post_skill_addtimerskill) (int retVal___, struct block_list *src, int64 tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag); +typedef int (*HPMHOOK_pre_skill_additional_effect) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); +typedef int (*HPMHOOK_post_skill_additional_effect) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, int64 tick); +typedef int (*HPMHOOK_pre_skill_counter_additional_effect) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); +typedef int (*HPMHOOK_post_skill_counter_additional_effect) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int64 tick); +typedef int (*HPMHOOK_pre_skill_blown) (struct block_list **src, struct block_list **target, int *count, int8 *dir, int *flag); +typedef int (*HPMHOOK_post_skill_blown) (int retVal___, struct block_list *src, struct block_list *target, int count, int8 dir, int flag); +typedef int (*HPMHOOK_pre_skill_break_equip) (struct block_list **bl, unsigned short *where, int *rate, int *flag); +typedef int (*HPMHOOK_post_skill_break_equip) (int retVal___, struct block_list *bl, unsigned short where, int rate, int flag); +typedef int (*HPMHOOK_pre_skill_strip_equip) (struct block_list **bl, unsigned short *where, int *rate, int *lv, int *time); +typedef int (*HPMHOOK_post_skill_strip_equip) (int retVal___, struct block_list *bl, unsigned short where, int rate, int lv, int time); +typedef struct skill_unit_group* (*HPMHOOK_pre_skill_id2group) (int *group_id); +typedef struct skill_unit_group* (*HPMHOOK_post_skill_id2group) (struct skill_unit_group* retVal___, int group_id); +typedef struct skill_unit_group* (*HPMHOOK_pre_skill_unitsetting) (struct block_list **src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag); +typedef struct skill_unit_group* (*HPMHOOK_post_skill_unitsetting) (struct skill_unit_group* retVal___, struct block_list *src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag); +typedef struct skill_unit* (*HPMHOOK_pre_skill_initunit) (struct skill_unit_group **group, int *idx, int *x, int *y, int *val1, int *val2); +typedef struct skill_unit* (*HPMHOOK_post_skill_initunit) (struct skill_unit* retVal___, struct skill_unit_group *group, int idx, int x, int y, int val1, int val2); +typedef int (*HPMHOOK_pre_skill_delunit) (struct skill_unit **su); +typedef int (*HPMHOOK_post_skill_delunit) (int retVal___, struct skill_unit *su); +typedef struct skill_unit_group* (*HPMHOOK_pre_skill_init_unitgroup) (struct block_list **src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval); +typedef struct skill_unit_group* (*HPMHOOK_post_skill_init_unitgroup) (struct skill_unit_group* retVal___, struct block_list *src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval); +typedef int (*HPMHOOK_pre_skill_del_unitgroup) (struct skill_unit_group **group, const char **file, int *line, const char **func); +typedef int (*HPMHOOK_post_skill_del_unitgroup) (int retVal___, struct skill_unit_group *group, const char *file, int line, const char *func); +typedef int (*HPMHOOK_pre_skill_clear_unitgroup) (struct block_list **src); +typedef int (*HPMHOOK_post_skill_clear_unitgroup) (int retVal___, struct block_list *src); +typedef int (*HPMHOOK_pre_skill_clear_group) (struct block_list **bl, int *flag); +typedef int (*HPMHOOK_post_skill_clear_group) (int retVal___, struct block_list *bl, int flag); +typedef int (*HPMHOOK_pre_skill_unit_onplace) (struct skill_unit **src, struct block_list **bl, int64 *tick); +typedef int (*HPMHOOK_post_skill_unit_onplace) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); +typedef int (*HPMHOOK_pre_skill_unit_ondamaged) (struct skill_unit **src, struct block_list **bl, int64 *damage, int64 *tick); +typedef int (*HPMHOOK_post_skill_unit_ondamaged) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 damage, int64 tick); +typedef int (*HPMHOOK_pre_skill_cast_fix) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_cast_fix) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_cast_fix_sc) (struct block_list **bl, int *time); +typedef int (*HPMHOOK_post_skill_cast_fix_sc) (int retVal___, struct block_list *bl, int time); +typedef int (*HPMHOOK_pre_skill_vf_cast_fix) (struct block_list **bl, double *time, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_vf_cast_fix) (int retVal___, struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_delay_fix) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_delay_fix) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_check_condition_castbegin) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_check_condition_castbegin) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_check_condition_castend) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_check_condition_castend) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_consume_requirement) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv, short *type); +typedef int (*HPMHOOK_post_skill_consume_requirement) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type); +typedef struct skill_condition (*HPMHOOK_pre_skill_get_requirement) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef struct skill_condition (*HPMHOOK_post_skill_get_requirement) (struct skill_condition retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_check_pc_partner) (struct map_session_data **sd, uint16 *skill_id, uint16 **skill_lv, int *range, int *cast_flag); +typedef int (*HPMHOOK_post_skill_check_pc_partner) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 *skill_lv, int range, int cast_flag); +typedef int (*HPMHOOK_pre_skill_unit_move) (struct block_list **bl, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_unit_move) (int retVal___, struct block_list *bl, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_unit_onleft) (uint16 *skill_id, struct block_list **bl, int64 *tick); +typedef int (*HPMHOOK_post_skill_unit_onleft) (int retVal___, uint16 skill_id, struct block_list *bl, int64 tick); +typedef int (*HPMHOOK_pre_skill_unit_onout) (struct skill_unit **src, struct block_list **bl, int64 *tick); +typedef int (*HPMHOOK_post_skill_unit_onout) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); +typedef int (*HPMHOOK_pre_skill_unit_move_unit_group) (struct skill_unit_group **group, int16 *m, int16 *dx, int16 *dy); +typedef int (*HPMHOOK_post_skill_unit_move_unit_group) (int retVal___, struct skill_unit_group *group, int16 m, int16 dx, int16 dy); +typedef int (*HPMHOOK_pre_skill_sit) (struct map_session_data **sd, int *type); +typedef int (*HPMHOOK_post_skill_sit) (int retVal___, struct map_session_data *sd, int type); +typedef void (*HPMHOOK_pre_skill_brandishspear) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef void (*HPMHOOK_post_skill_brandishspear) (struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef void (*HPMHOOK_pre_skill_repairweapon) (struct map_session_data **sd, int *idx); +typedef void (*HPMHOOK_post_skill_repairweapon) (struct map_session_data *sd, int idx); +typedef void (*HPMHOOK_pre_skill_identify) (struct map_session_data **sd, int *idx); +typedef void (*HPMHOOK_post_skill_identify) (struct map_session_data *sd, int idx); +typedef void (*HPMHOOK_pre_skill_weaponrefine) (struct map_session_data **sd, int *idx); +typedef void (*HPMHOOK_post_skill_weaponrefine) (struct map_session_data *sd, int idx); +typedef int (*HPMHOOK_pre_skill_autospell) (struct map_session_data **md, uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_autospell) (int retVal___, struct map_session_data *md, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_calc_heal) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, bool *heal); +typedef int (*HPMHOOK_post_skill_calc_heal) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal); +typedef bool (*HPMHOOK_pre_skill_check_cloaking) (struct block_list **bl, struct status_change_entry **sce); +typedef bool (*HPMHOOK_post_skill_check_cloaking) (bool retVal___, struct block_list *bl, struct status_change_entry *sce); +typedef int (*HPMHOOK_pre_skill_check_cloaking_end) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_check_cloaking_end) (int retVal___, struct block_list *bl, va_list ap); +typedef bool (*HPMHOOK_pre_skill_can_cloak) (struct map_session_data **sd); +typedef bool (*HPMHOOK_post_skill_can_cloak) (bool retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_skill_enchant_elemental_end) (struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_skill_enchant_elemental_end) (int retVal___, struct block_list *bl, int type); +typedef int (*HPMHOOK_pre_skill_not_ok) (uint16 *skill_id, struct map_session_data **sd); +typedef int (*HPMHOOK_post_skill_not_ok) (int retVal___, uint16 skill_id, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_skill_not_ok_hom) (uint16 *skill_id, struct homun_data **hd); +typedef int (*HPMHOOK_post_skill_not_ok_hom) (int retVal___, uint16 skill_id, struct homun_data *hd); +typedef int (*HPMHOOK_pre_skill_not_ok_mercenary) (uint16 *skill_id, struct mercenary_data **md); +typedef int (*HPMHOOK_post_skill_not_ok_mercenary) (int retVal___, uint16 skill_id, struct mercenary_data *md); +typedef int (*HPMHOOK_pre_skill_chastle_mob_changetarget) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_chastle_mob_changetarget) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_can_produce_mix) (struct map_session_data **sd, int *nameid, int *trigger, int *qty); +typedef int (*HPMHOOK_post_skill_can_produce_mix) (int retVal___, struct map_session_data *sd, int nameid, int trigger, int qty); +typedef int (*HPMHOOK_pre_skill_produce_mix) (struct map_session_data **sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty); +typedef int (*HPMHOOK_post_skill_produce_mix) (int retVal___, struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty); +typedef int (*HPMHOOK_pre_skill_arrow_create) (struct map_session_data **sd, int *nameid); +typedef int (*HPMHOOK_post_skill_arrow_create) (int retVal___, struct map_session_data *sd, int nameid); +typedef int (*HPMHOOK_pre_skill_castend_nodamage_id) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_castend_nodamage_id) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_castend_damage_id) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_castend_damage_id) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_castend_pos2) (struct block_list **src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_castend_pos2) (int retVal___, struct block_list *src, int x, int y, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_blockpc_start) (struct map_session_data **sd, uint16 *skill_id, int *tick); +typedef int (*HPMHOOK_post_skill_blockpc_start) (int retVal___, struct map_session_data *sd, uint16 skill_id, int tick); +typedef int (*HPMHOOK_pre_skill_blockhomun_start) (struct homun_data **hd, uint16 *skill_id, int *tick); +typedef int (*HPMHOOK_post_skill_blockhomun_start) (int retVal___, struct homun_data *hd, uint16 skill_id, int tick); +typedef int (*HPMHOOK_pre_skill_blockmerc_start) (struct mercenary_data **md, uint16 *skill_id, int *tick); +typedef int (*HPMHOOK_post_skill_blockmerc_start) (int retVal___, struct mercenary_data *md, uint16 skill_id, int tick); +typedef int (*HPMHOOK_pre_skill_attack) (int *attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_attack) (int retVal___, int attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_attack_area) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_attack_area) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_area_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_area_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_area_sub_count) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_post_skill_area_sub_count) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); +typedef int (*HPMHOOK_pre_skill_check_unit_range) (struct block_list **bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_check_unit_range) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_check_unit_range_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_check_unit_range_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_check_unit_range2) (struct block_list **bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_check_unit_range2) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_check_unit_range2_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_check_unit_range2_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_skill_toggle_magicpower) (struct block_list **bl, uint16 *skill_id); +typedef void (*HPMHOOK_post_skill_toggle_magicpower) (struct block_list *bl, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_magic_reflect) (struct block_list **src, struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_skill_magic_reflect) (int retVal___, struct block_list *src, struct block_list *bl, int type); +typedef int (*HPMHOOK_pre_skill_onskillusage) (struct map_session_data **sd, struct block_list **bl, uint16 *skill_id, int64 *tick); +typedef int (*HPMHOOK_post_skill_onskillusage) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick); +typedef int (*HPMHOOK_pre_skill_cell_overlap) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_cell_overlap) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_timerskill) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_timerskill) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_trap_splash) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_trap_splash) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_check_condition_mercenary) (struct block_list **bl, int *skill_id, int *lv, int *type); +typedef int (*HPMHOOK_post_skill_check_condition_mercenary) (int retVal___, struct block_list *bl, int skill_id, int lv, int type); +typedef struct skill_unit_group* (*HPMHOOK_pre_skill_locate_element_field) (struct block_list **bl); +typedef struct skill_unit_group* (*HPMHOOK_post_skill_locate_element_field) (struct skill_unit_group* retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_skill_graffitiremover) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_graffitiremover) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_activate_reverberation) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_activate_reverberation) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_dance_overlap_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_dance_overlap_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_dance_overlap) (struct skill_unit **su, int *flag); +typedef int (*HPMHOOK_post_skill_dance_overlap) (int retVal___, struct skill_unit *su, int flag); +typedef struct s_skill_unit_layout* (*HPMHOOK_pre_skill_get_unit_layout) (uint16 *skill_id, uint16 *skill_lv, struct block_list **src, int *x, int *y); +typedef struct s_skill_unit_layout* (*HPMHOOK_post_skill_get_unit_layout) (struct s_skill_unit_layout* retVal___, uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y); +typedef int (*HPMHOOK_pre_skill_frostjoke_scream) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_frostjoke_scream) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_greed) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_greed) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_destroy_trap) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_destroy_trap) (int retVal___, struct block_list *bl, va_list ap); +typedef struct skill_unit_group_tickset* (*HPMHOOK_pre_skill_unitgrouptickset_search) (struct block_list **bl, struct skill_unit_group **group, int64 *tick); +typedef struct skill_unit_group_tickset* (*HPMHOOK_post_skill_unitgrouptickset_search) (struct skill_unit_group_tickset* retVal___, struct block_list *bl, struct skill_unit_group *group, int64 tick); +typedef bool (*HPMHOOK_pre_skill_dance_switch) (struct skill_unit **su, int *flag); +typedef bool (*HPMHOOK_post_skill_dance_switch) (bool retVal___, struct skill_unit *su, int flag); +typedef int (*HPMHOOK_pre_skill_check_condition_char_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_check_condition_char_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_check_condition_mob_master_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_check_condition_mob_master_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_skill_brandishspear_first) (struct square **tc, uint8 *dir, int16 *x, int16 *y); +typedef void (*HPMHOOK_post_skill_brandishspear_first) (struct square *tc, uint8 dir, int16 x, int16 y); +typedef void (*HPMHOOK_pre_skill_brandishspear_dir) (struct square **tc, uint8 *dir, int *are); +typedef void (*HPMHOOK_post_skill_brandishspear_dir) (struct square *tc, uint8 dir, int are); +typedef int (*HPMHOOK_pre_skill_get_fixed_cast) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_fixed_cast) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_skill_sit_count) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_sit_count) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_sit_in) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_sit_in) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_sit_out) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_sit_out) (int retVal___, struct block_list *bl, va_list ap); +typedef void (*HPMHOOK_pre_skill_unitsetmapcell) (struct skill_unit **src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag); +typedef void (*HPMHOOK_post_skill_unitsetmapcell) (struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag); +typedef int (*HPMHOOK_pre_skill_unit_onplace_timer) (struct skill_unit **src, struct block_list **bl, int64 *tick); +typedef int (*HPMHOOK_post_skill_unit_onplace_timer) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); +typedef int (*HPMHOOK_pre_skill_unit_effect) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_unit_effect) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_unit_timer_sub_onplace) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_unit_timer_sub_onplace) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_unit_move_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_unit_move_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_skill_blockpc_end) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_blockpc_end) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_blockhomun_end) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_blockhomun_end) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_blockmerc_end) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_blockmerc_end) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_split_atoi) (char **str, int **val); +typedef int (*HPMHOOK_post_skill_split_atoi) (int retVal___, char *str, int *val); +typedef int (*HPMHOOK_pre_skill_unit_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_skill_unit_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_skill_unit_timer_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_skill_unit_timer_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +typedef void (*HPMHOOK_pre_skill_init_unit_layout) (void); +typedef void (*HPMHOOK_post_skill_init_unit_layout) (void); +typedef bool (*HPMHOOK_pre_skill_parse_row_skilldb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_skilldb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_requiredb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_requiredb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_castdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_castdb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_castnodexdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_castnodexdb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_unitdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_unitdb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_producedb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_producedb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_createarrowdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_createarrowdb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_abradb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_abradb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_spellbookdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_spellbookdb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_magicmushroomdb) (char **split[], int *column, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_magicmushroomdb) (bool retVal___, char *split[], int column, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_reproducedb) (char **split[], int *column, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_reproducedb) (bool retVal___, char *split[], int column, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_improvisedb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_improvisedb) (bool retVal___, char *split[], int columns, int current); +typedef bool (*HPMHOOK_pre_skill_parse_row_changematerialdb) (char **split[], int *columns, int *current); +typedef bool (*HPMHOOK_post_skill_parse_row_changematerialdb) (bool retVal___, char *split[], int columns, int current); +typedef void (*HPMHOOK_pre_skill_usave_add) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); +typedef void (*HPMHOOK_post_skill_usave_add) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); +typedef void (*HPMHOOK_pre_skill_usave_trigger) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_skill_usave_trigger) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_skill_cooldown_load) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_skill_cooldown_load) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_skill_spellbook) (struct map_session_data **sd, int *nameid); +typedef int (*HPMHOOK_post_skill_spellbook) (int retVal___, struct map_session_data *sd, int nameid); +typedef int (*HPMHOOK_pre_skill_block_check) (struct block_list **bl, enum sc_type *type, uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_block_check) (int retVal___, struct block_list *bl, enum sc_type type, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_detonator) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_detonator) (int retVal___, struct block_list *bl, va_list ap); +typedef bool (*HPMHOOK_pre_skill_check_camouflage) (struct block_list **bl, struct status_change_entry **sce); +typedef bool (*HPMHOOK_post_skill_check_camouflage) (bool retVal___, struct block_list *bl, struct status_change_entry *sce); +typedef int (*HPMHOOK_pre_skill_magicdecoy) (struct map_session_data **sd, int *nameid); +typedef int (*HPMHOOK_post_skill_magicdecoy) (int retVal___, struct map_session_data *sd, int nameid); +typedef int (*HPMHOOK_pre_skill_poisoningweapon) (struct map_session_data **sd, int *nameid); +typedef int (*HPMHOOK_post_skill_poisoningweapon) (int retVal___, struct map_session_data *sd, int nameid); +typedef int (*HPMHOOK_pre_skill_select_menu) (struct map_session_data **sd, uint16 *skill_id); +typedef int (*HPMHOOK_post_skill_select_menu) (int retVal___, struct map_session_data *sd, uint16 skill_id); +typedef int (*HPMHOOK_pre_skill_elementalanalysis) (struct map_session_data **sd, uint16 *skill_lv, const struct itemlist **item_list); +typedef int (*HPMHOOK_post_skill_elementalanalysis) (int retVal___, struct map_session_data *sd, uint16 skill_lv, const struct itemlist *item_list); +typedef int (*HPMHOOK_pre_skill_changematerial) (struct map_session_data **sd, const struct itemlist **item_list); +typedef int (*HPMHOOK_post_skill_changematerial) (int retVal___, struct map_session_data *sd, const struct itemlist *item_list); +typedef int (*HPMHOOK_pre_skill_get_elemental_type) (uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_skill_get_elemental_type) (int retVal___, uint16 skill_id, uint16 skill_lv); +typedef void (*HPMHOOK_pre_skill_cooldown_save) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_skill_cooldown_save) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_skill_get_new_group_id) (void); +typedef int (*HPMHOOK_post_skill_get_new_group_id) (int retVal___); +typedef bool (*HPMHOOK_pre_skill_check_shadowform) (struct block_list **bl, int64 *damage, int *hit); +typedef bool (*HPMHOOK_post_skill_check_shadowform) (bool retVal___, struct block_list *bl, int64 damage, int hit); +typedef bool (*HPMHOOK_pre_skill_castend_damage_id_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, struct status_data **tstatus, struct status_change **sc); +typedef bool (*HPMHOOK_post_skill_castend_damage_id_unknown) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc); +typedef void (*HPMHOOK_pre_skill_additional_effect_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int **attack_type, int **dmg_lv, int64 **tick); +typedef void (*HPMHOOK_post_skill_additional_effect_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); +typedef void (*HPMHOOK_pre_skill_counter_additional_effect_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int **attack_type, int64 **tick); +typedef void (*HPMHOOK_post_skill_counter_additional_effect_unknown) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); +typedef void (*HPMHOOK_pre_skill_attack_combo1_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, struct status_change_entry **sce, int **combo); +typedef void (*HPMHOOK_post_skill_attack_combo1_unknown) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo); +typedef void (*HPMHOOK_pre_skill_attack_combo2_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **combo); +typedef void (*HPMHOOK_post_skill_attack_combo2_unknown) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo); +typedef void (*HPMHOOK_pre_skill_attack_display_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **type, struct Damage **dmg, int64 **damage); +typedef void (*HPMHOOK_post_skill_attack_display_unknown) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage); +typedef int (*HPMHOOK_pre_skill_attack_copy_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef int (*HPMHOOK_post_skill_attack_copy_unknown) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef int (*HPMHOOK_pre_skill_attack_dir_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef int (*HPMHOOK_post_skill_attack_dir_unknown) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef void (*HPMHOOK_pre_skill_attack_blow_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **type, struct Damage **dmg, int64 **damage, int8 **dir); +typedef void (*HPMHOOK_post_skill_attack_blow_unknown) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir); +typedef void (*HPMHOOK_pre_skill_attack_post_unknown) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef void (*HPMHOOK_post_skill_attack_post_unknown) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef bool (*HPMHOOK_pre_skill_timerskill_dead_unknown) (struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl); +typedef bool (*HPMHOOK_post_skill_timerskill_dead_unknown) (bool retVal___, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); +typedef void (*HPMHOOK_pre_skill_timerskill_target_unknown) (int *tid, int64 *tick, struct block_list **src, struct block_list **target, struct unit_data **ud, struct skill_timerskill **skl); +typedef void (*HPMHOOK_post_skill_timerskill_target_unknown) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl); +typedef void (*HPMHOOK_pre_skill_timerskill_notarget_unknown) (int *tid, int64 *tick, struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl); +typedef void (*HPMHOOK_post_skill_timerskill_notarget_unknown) (int tid, int64 tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); +typedef bool (*HPMHOOK_pre_skill_cleartimerskill_exception) (int *skill_id); +typedef bool (*HPMHOOK_post_skill_cleartimerskill_exception) (bool retVal___, int skill_id); +typedef bool (*HPMHOOK_pre_skill_castend_id_unknown) (struct unit_data **ud, struct block_list **src, struct block_list **target); +typedef bool (*HPMHOOK_post_skill_castend_id_unknown) (bool retVal___, struct unit_data *ud, struct block_list *src, struct block_list *target); +typedef bool (*HPMHOOK_pre_skill_castend_nodamage_id_dead_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef bool (*HPMHOOK_post_skill_castend_nodamage_id_dead_unknown) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef bool (*HPMHOOK_pre_skill_castend_nodamage_id_undead_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef bool (*HPMHOOK_post_skill_castend_nodamage_id_undead_unknown) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef bool (*HPMHOOK_pre_skill_castend_nodamage_id_mado_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef bool (*HPMHOOK_post_skill_castend_nodamage_id_mado_unknown) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef bool (*HPMHOOK_pre_skill_castend_nodamage_id_unknown) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef bool (*HPMHOOK_post_skill_castend_nodamage_id_unknown) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef void (*HPMHOOK_pre_skill_castend_pos2_effect_unknown) (struct block_list **src, int **x, int **y, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef void (*HPMHOOK_post_skill_castend_pos2_effect_unknown) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef bool (*HPMHOOK_pre_skill_castend_pos2_unknown) (struct block_list **src, int **x, int **y, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); +typedef bool (*HPMHOOK_post_skill_castend_pos2_unknown) (bool retVal___, struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); +typedef void (*HPMHOOK_pre_skill_unitsetting1_unknown) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **val1, int **val2, int **val3); +typedef void (*HPMHOOK_post_skill_unitsetting1_unknown) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3); +typedef void (*HPMHOOK_pre_skill_unitsetting2_unknown) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **unit_flag, int **val1, int **val2, int **val3, struct skill_unit_group **group); +typedef void (*HPMHOOK_post_skill_unitsetting2_unknown) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group); +typedef void (*HPMHOOK_pre_skill_unit_onplace_unknown) (struct skill_unit **src, struct block_list **bl, int64 **tick); +typedef void (*HPMHOOK_post_skill_unit_onplace_unknown) (struct skill_unit *src, struct block_list *bl, int64 *tick); +typedef int (*HPMHOOK_pre_skill_check_condition_castbegin_off_unknown) (struct status_change **sc, uint16 **skill_id); +typedef int (*HPMHOOK_post_skill_check_condition_castbegin_off_unknown) (int retVal___, struct status_change *sc, uint16 *skill_id); +typedef int (*HPMHOOK_pre_skill_check_condition_castbegin_mount_unknown) (struct status_change **sc, uint16 **skill_id); +typedef int (*HPMHOOK_post_skill_check_condition_castbegin_mount_unknown) (int retVal___, struct status_change *sc, uint16 *skill_id); +typedef int (*HPMHOOK_pre_skill_check_condition_castbegin_madogear_unknown) (struct status_change **sc, uint16 **skill_id); +typedef int (*HPMHOOK_post_skill_check_condition_castbegin_madogear_unknown) (int retVal___, struct status_change *sc, uint16 *skill_id); +typedef int (*HPMHOOK_pre_skill_check_condition_castbegin_unknown) (struct status_change **sc, uint16 **skill_id); +typedef int (*HPMHOOK_post_skill_check_condition_castbegin_unknown) (int retVal___, struct status_change *sc, uint16 *skill_id); +typedef void (*HPMHOOK_pre_skill_check_condition_castend_unknown) (struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv); +typedef void (*HPMHOOK_post_skill_check_condition_castend_unknown) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); +typedef bool (*HPMHOOK_pre_skill_get_requirement_off_unknown) (struct status_change **sc, uint16 **skill_id); +typedef bool (*HPMHOOK_post_skill_get_requirement_off_unknown) (bool retVal___, struct status_change *sc, uint16 *skill_id); +typedef bool (*HPMHOOK_pre_skill_get_requirement_item_unknown) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, uint16 **idx, int **i); +typedef bool (*HPMHOOK_post_skill_get_requirement_item_unknown) (bool retVal___, struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i); +typedef void (*HPMHOOK_pre_skill_get_requirement_unknown) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, struct skill_condition **req); +typedef void (*HPMHOOK_post_skill_get_requirement_unknown) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req); +typedef int (*HPMHOOK_pre_skill_splash_target) (struct block_list **bl); +typedef int (*HPMHOOK_post_skill_splash_target) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_skill_check_npc_chaospanic) (struct block_list **bl, va_list args); +typedef int (*HPMHOOK_post_skill_check_npc_chaospanic) (int retVal___, struct block_list *bl, va_list args); +typedef int (*HPMHOOK_pre_skill_count_wos) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_skill_count_wos) (int retVal___, struct block_list *bl, va_list ap); +#endif // MAP_SKILL_H +#ifdef COMMON_SOCKET_H /* sockt */ +typedef void (*HPMHOOK_pre_sockt_init) (void); +typedef void (*HPMHOOK_post_sockt_init) (void); +typedef void (*HPMHOOK_pre_sockt_final) (void); +typedef void (*HPMHOOK_post_sockt_final) (void); +typedef int (*HPMHOOK_pre_sockt_perform) (int *next); +typedef int (*HPMHOOK_post_sockt_perform) (int retVal___, int next); +typedef void (*HPMHOOK_pre_sockt_datasync) (int *fd, bool *send); +typedef void (*HPMHOOK_post_sockt_datasync) (int fd, bool send); +typedef int (*HPMHOOK_pre_sockt_make_listen_bind) (uint32 *ip, uint16 *port); +typedef int (*HPMHOOK_post_sockt_make_listen_bind) (int retVal___, uint32 ip, uint16 port); +typedef int (*HPMHOOK_pre_sockt_make_connection) (uint32 *ip, uint16 *port, struct hSockOpt **opt); +typedef int (*HPMHOOK_post_sockt_make_connection) (int retVal___, uint32 ip, uint16 port, struct hSockOpt *opt); +typedef int (*HPMHOOK_pre_sockt_realloc_fifo) (int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); +typedef int (*HPMHOOK_post_sockt_realloc_fifo) (int retVal___, int fd, unsigned int rfifo_size, unsigned int wfifo_size); +typedef int (*HPMHOOK_pre_sockt_realloc_writefifo) (int *fd, size_t *addition); +typedef int (*HPMHOOK_post_sockt_realloc_writefifo) (int retVal___, int fd, size_t addition); +typedef int (*HPMHOOK_pre_sockt_wfifoset) (int *fd, size_t *len); +typedef int (*HPMHOOK_post_sockt_wfifoset) (int retVal___, int fd, size_t len); +typedef int (*HPMHOOK_pre_sockt_rfifoskip) (int *fd, size_t *len); +typedef int (*HPMHOOK_post_sockt_rfifoskip) (int retVal___, int fd, size_t len); +typedef void (*HPMHOOK_pre_sockt_close) (int *fd); +typedef void (*HPMHOOK_post_sockt_close) (int fd); +typedef bool (*HPMHOOK_pre_sockt_session_is_valid) (int *fd); +typedef bool (*HPMHOOK_post_sockt_session_is_valid) (bool retVal___, int fd); +typedef bool (*HPMHOOK_pre_sockt_session_is_active) (int *fd); +typedef bool (*HPMHOOK_post_sockt_session_is_active) (bool retVal___, int fd); +typedef void (*HPMHOOK_pre_sockt_flush) (int *fd); +typedef void (*HPMHOOK_post_sockt_flush) (int fd); +typedef void (*HPMHOOK_pre_sockt_flush_fifos) (void); +typedef void (*HPMHOOK_post_sockt_flush_fifos) (void); +typedef void (*HPMHOOK_pre_sockt_set_nonblocking) (int *fd, unsigned long *yes); +typedef void (*HPMHOOK_post_sockt_set_nonblocking) (int fd, unsigned long yes); +typedef void (*HPMHOOK_pre_sockt_set_defaultparse) (ParseFunc *defaultparse); +typedef void (*HPMHOOK_post_sockt_set_defaultparse) (ParseFunc defaultparse); +typedef uint32 (*HPMHOOK_pre_sockt_host2ip) (const char **hostname); +typedef uint32 (*HPMHOOK_post_sockt_host2ip) (uint32 retVal___, const char *hostname); +typedef const char* (*HPMHOOK_pre_sockt_ip2str) (uint32 *ip, char **ip_str); +typedef const char* (*HPMHOOK_post_sockt_ip2str) (const char* retVal___, uint32 ip, char *ip_str); +typedef uint32 (*HPMHOOK_pre_sockt_str2ip) (const char **ip_str); +typedef uint32 (*HPMHOOK_post_sockt_str2ip) (uint32 retVal___, const char *ip_str); +typedef uint16 (*HPMHOOK_pre_sockt_ntows) (uint16 *netshort); +typedef uint16 (*HPMHOOK_post_sockt_ntows) (uint16 retVal___, uint16 netshort); +typedef int (*HPMHOOK_pre_sockt_getips) (uint32 **ips, int *max); +typedef int (*HPMHOOK_post_sockt_getips) (int retVal___, uint32 *ips, int max); +typedef void (*HPMHOOK_pre_sockt_eof) (int *fd); +typedef void (*HPMHOOK_post_sockt_eof) (int fd); +typedef uint32 (*HPMHOOK_pre_sockt_lan_subnet_check) (uint32 *ip, struct s_subnet **info); +typedef uint32 (*HPMHOOK_post_sockt_lan_subnet_check) (uint32 retVal___, uint32 ip, struct s_subnet *info); +typedef bool (*HPMHOOK_pre_sockt_allowed_ip_check) (uint32 *ip); +typedef bool (*HPMHOOK_post_sockt_allowed_ip_check) (bool retVal___, uint32 ip); +typedef bool (*HPMHOOK_pre_sockt_trusted_ip_check) (uint32 *ip); +typedef bool (*HPMHOOK_post_sockt_trusted_ip_check) (bool retVal___, uint32 ip); +typedef int (*HPMHOOK_pre_sockt_net_config_read_sub) (struct config_setting_t **t, struct s_subnet_vector **list, const char **filename, const char **groupname); +typedef int (*HPMHOOK_post_sockt_net_config_read_sub) (int retVal___, struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname); +typedef void (*HPMHOOK_pre_sockt_net_config_read) (const char **filename); +typedef void (*HPMHOOK_post_sockt_net_config_read) (const char *filename); +#endif // COMMON_SOCKET_H +#ifdef COMMON_SQL_H /* SQL */ +typedef int (*HPMHOOK_pre_SQL_Connect) (struct Sql **self, const char **user, const char **passwd, const char **host, uint16 *port, const char **db); +typedef int (*HPMHOOK_post_SQL_Connect) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db); +typedef int (*HPMHOOK_pre_SQL_GetTimeout) (struct Sql **self, uint32 **out_timeout); +typedef int (*HPMHOOK_post_SQL_GetTimeout) (int retVal___, struct Sql *self, uint32 *out_timeout); +typedef int (*HPMHOOK_pre_SQL_GetColumnNames) (struct Sql **self, const char **table, char **out_buf, size_t *buf_len, char *sep); +typedef int (*HPMHOOK_post_SQL_GetColumnNames) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep); +typedef int (*HPMHOOK_pre_SQL_SetEncoding) (struct Sql **self, const char **encoding); +typedef int (*HPMHOOK_post_SQL_SetEncoding) (int retVal___, struct Sql *self, const char *encoding); +typedef int (*HPMHOOK_pre_SQL_Ping) (struct Sql **self); +typedef int (*HPMHOOK_post_SQL_Ping) (int retVal___, struct Sql *self); +typedef size_t (*HPMHOOK_pre_SQL_EscapeString) (struct Sql **self, char **out_to, const char **from); +typedef size_t (*HPMHOOK_post_SQL_EscapeString) (size_t retVal___, struct Sql *self, char *out_to, const char *from); +typedef size_t (*HPMHOOK_pre_SQL_EscapeStringLen) (struct Sql **self, char **out_to, const char **from, size_t *from_len); +typedef size_t (*HPMHOOK_post_SQL_EscapeStringLen) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t from_len); +typedef int (*HPMHOOK_pre_SQL_QueryV) (struct Sql **self, const char **query, va_list args); +typedef int (*HPMHOOK_post_SQL_QueryV) (int retVal___, struct Sql *self, const char *query, va_list args); +typedef int (*HPMHOOK_pre_SQL_QueryStr) (struct Sql **self, const char **query); +typedef int (*HPMHOOK_post_SQL_QueryStr) (int retVal___, struct Sql *self, const char *query); +typedef uint64 (*HPMHOOK_pre_SQL_LastInsertId) (struct Sql **self); +typedef uint64 (*HPMHOOK_post_SQL_LastInsertId) (uint64 retVal___, struct Sql *self); +typedef uint32 (*HPMHOOK_pre_SQL_NumColumns) (struct Sql **self); +typedef uint32 (*HPMHOOK_post_SQL_NumColumns) (uint32 retVal___, struct Sql *self); +typedef uint64 (*HPMHOOK_pre_SQL_NumRows) (struct Sql **self); +typedef uint64 (*HPMHOOK_post_SQL_NumRows) (uint64 retVal___, struct Sql *self); +typedef int (*HPMHOOK_pre_SQL_NextRow) (struct Sql **self); +typedef int (*HPMHOOK_post_SQL_NextRow) (int retVal___, struct Sql *self); +typedef int (*HPMHOOK_pre_SQL_GetData) (struct Sql **self, size_t *col, char ***out_buf, size_t **out_len); +typedef int (*HPMHOOK_post_SQL_GetData) (int retVal___, struct Sql *self, size_t col, char **out_buf, size_t *out_len); +typedef void (*HPMHOOK_pre_SQL_FreeResult) (struct Sql **self); +typedef void (*HPMHOOK_post_SQL_FreeResult) (struct Sql *self); +typedef void (*HPMHOOK_pre_SQL_ShowDebug_) (struct Sql **self, const char **debug_file, const unsigned long *debug_line); +typedef void (*HPMHOOK_post_SQL_ShowDebug_) (struct Sql *self, const char *debug_file, const unsigned long debug_line); +typedef void (*HPMHOOK_pre_SQL_Free) (struct Sql **self); +typedef void (*HPMHOOK_post_SQL_Free) (struct Sql *self); +typedef struct Sql* (*HPMHOOK_pre_SQL_Malloc) (void); +typedef struct Sql* (*HPMHOOK_post_SQL_Malloc) (struct Sql* retVal___); +typedef struct SqlStmt* (*HPMHOOK_pre_SQL_StmtMalloc) (struct Sql **sql); +typedef struct SqlStmt* (*HPMHOOK_post_SQL_StmtMalloc) (struct SqlStmt* retVal___, struct Sql *sql); +typedef int (*HPMHOOK_pre_SQL_StmtPrepareV) (struct SqlStmt **self, const char **query, va_list args); +typedef int (*HPMHOOK_post_SQL_StmtPrepareV) (int retVal___, struct SqlStmt *self, const char *query, va_list args); +typedef int (*HPMHOOK_pre_SQL_StmtPrepareStr) (struct SqlStmt **self, const char **query); +typedef int (*HPMHOOK_post_SQL_StmtPrepareStr) (int retVal___, struct SqlStmt *self, const char *query); +typedef size_t (*HPMHOOK_pre_SQL_StmtNumParams) (struct SqlStmt **self); +typedef size_t (*HPMHOOK_post_SQL_StmtNumParams) (size_t retVal___, struct SqlStmt *self); +typedef int (*HPMHOOK_pre_SQL_StmtBindParam) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const void **buffer, size_t *buffer_len); +typedef int (*HPMHOOK_post_SQL_StmtBindParam) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len); +typedef int (*HPMHOOK_pre_SQL_StmtExecute) (struct SqlStmt **self); +typedef int (*HPMHOOK_post_SQL_StmtExecute) (int retVal___, struct SqlStmt *self); +typedef uint64 (*HPMHOOK_pre_SQL_StmtLastInsertId) (struct SqlStmt **self); +typedef uint64 (*HPMHOOK_post_SQL_StmtLastInsertId) (uint64 retVal___, struct SqlStmt *self); +typedef size_t (*HPMHOOK_pre_SQL_StmtNumColumns) (struct SqlStmt **self); +typedef size_t (*HPMHOOK_post_SQL_StmtNumColumns) (size_t retVal___, struct SqlStmt *self); +typedef int (*HPMHOOK_pre_SQL_StmtBindColumn) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, void **buffer, size_t *buffer_len, uint32 **out_length, int8 **out_is_null); +typedef int (*HPMHOOK_post_SQL_StmtBindColumn) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null); +typedef uint64 (*HPMHOOK_pre_SQL_StmtNumRows) (struct SqlStmt **self); +typedef uint64 (*HPMHOOK_post_SQL_StmtNumRows) (uint64 retVal___, struct SqlStmt *self); +typedef int (*HPMHOOK_pre_SQL_StmtNextRow) (struct SqlStmt **self); +typedef int (*HPMHOOK_post_SQL_StmtNextRow) (int retVal___, struct SqlStmt *self); +typedef void (*HPMHOOK_pre_SQL_StmtFreeResult) (struct SqlStmt **self); +typedef void (*HPMHOOK_post_SQL_StmtFreeResult) (struct SqlStmt *self); +typedef void (*HPMHOOK_pre_SQL_StmtFree) (struct SqlStmt **self); +typedef void (*HPMHOOK_post_SQL_StmtFree) (struct SqlStmt *self); +typedef void (*HPMHOOK_pre_SQL_StmtShowDebug_) (struct SqlStmt **self, const char **debug_file, const unsigned long *debug_line); +typedef void (*HPMHOOK_post_SQL_StmtShowDebug_) (struct SqlStmt *self, const char *debug_file, const unsigned long debug_line); +#endif // COMMON_SQL_H +#ifdef MAP_STATUS_H /* status */ +typedef int (*HPMHOOK_pre_status_init) (bool *minimal); +typedef int (*HPMHOOK_post_status_init) (int retVal___, bool minimal); +typedef void (*HPMHOOK_pre_status_final) (void); +typedef void (*HPMHOOK_post_status_final) (void); +typedef int (*HPMHOOK_pre_status_get_refine_chance) (enum refine_type *wlv, int *refine); +typedef int (*HPMHOOK_post_status_get_refine_chance) (int retVal___, enum refine_type wlv, int refine); +typedef sc_type (*HPMHOOK_pre_status_skill2sc) (int *skill_id); +typedef sc_type (*HPMHOOK_post_status_skill2sc) (sc_type retVal___, int skill_id); +typedef int (*HPMHOOK_pre_status_sc2skill) (sc_type *sc); +typedef int (*HPMHOOK_post_status_sc2skill) (int retVal___, sc_type sc); +typedef unsigned int (*HPMHOOK_pre_status_sc2scb_flag) (sc_type *sc); +typedef unsigned int (*HPMHOOK_post_status_sc2scb_flag) (unsigned int retVal___, sc_type sc); +typedef int (*HPMHOOK_pre_status_type2relevant_bl_types) (int *type); +typedef int (*HPMHOOK_post_status_type2relevant_bl_types) (int retVal___, int type); +typedef int (*HPMHOOK_pre_status_get_sc_type) (sc_type *idx); +typedef int (*HPMHOOK_post_status_get_sc_type) (int retVal___, sc_type idx); +typedef int (*HPMHOOK_pre_status_damage) (struct block_list **src, struct block_list **target, int64 *hp, int64 *sp, int *walkdelay, int *flag); +typedef int (*HPMHOOK_post_status_damage) (int retVal___, struct block_list *src, struct block_list *target, int64 hp, int64 sp, int walkdelay, int flag); +typedef int (*HPMHOOK_pre_status_charge) (struct block_list **bl, int64 *hp, int64 *sp); +typedef int (*HPMHOOK_post_status_charge) (int retVal___, struct block_list *bl, int64 hp, int64 sp); +typedef int (*HPMHOOK_pre_status_percent_change) (struct block_list **src, struct block_list **target, signed char *hp_rate, signed char *sp_rate, int *flag); +typedef int (*HPMHOOK_post_status_percent_change) (int retVal___, struct block_list *src, struct block_list *target, signed char hp_rate, signed char sp_rate, int flag); +typedef int (*HPMHOOK_pre_status_set_hp) (struct block_list **bl, unsigned int *hp, int *flag); +typedef int (*HPMHOOK_post_status_set_hp) (int retVal___, struct block_list *bl, unsigned int hp, int flag); +typedef int (*HPMHOOK_pre_status_set_sp) (struct block_list **bl, unsigned int *sp, int *flag); +typedef int (*HPMHOOK_post_status_set_sp) (int retVal___, struct block_list *bl, unsigned int sp, int flag); +typedef int (*HPMHOOK_pre_status_heal) (struct block_list **bl, int64 *hp, int64 *sp, int *flag); +typedef int (*HPMHOOK_post_status_heal) (int retVal___, struct block_list *bl, int64 hp, int64 sp, int flag); +typedef int (*HPMHOOK_pre_status_revive) (struct block_list **bl, unsigned char *per_hp, unsigned char *per_sp); +typedef int (*HPMHOOK_post_status_revive) (int retVal___, struct block_list *bl, unsigned char per_hp, unsigned char per_sp); +typedef int (*HPMHOOK_pre_status_fixed_revive) (struct block_list **bl, unsigned int *per_hp, unsigned int *per_sp); +typedef int (*HPMHOOK_post_status_fixed_revive) (int retVal___, struct block_list *bl, unsigned int per_hp, unsigned int per_sp); +typedef struct regen_data* (*HPMHOOK_pre_status_get_regen_data) (struct block_list **bl); +typedef struct regen_data* (*HPMHOOK_post_status_get_regen_data) (struct regen_data* retVal___, struct block_list *bl); +typedef struct status_data* (*HPMHOOK_pre_status_get_status_data) (struct block_list **bl); +typedef struct status_data* (*HPMHOOK_post_status_get_status_data) (struct status_data* retVal___, struct block_list *bl); +typedef struct status_data* (*HPMHOOK_pre_status_get_base_status) (struct block_list **bl); +typedef struct status_data* (*HPMHOOK_post_status_get_base_status) (struct status_data* retVal___, struct block_list *bl); +typedef const char* (*HPMHOOK_pre_status_get_name) (const struct block_list **bl); +typedef const char* (*HPMHOOK_post_status_get_name) (const char* retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_class) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_class) (int retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_lv) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_lv) (int retVal___, const struct block_list *bl); +typedef defType (*HPMHOOK_pre_status_get_def) (struct block_list **bl); +typedef defType (*HPMHOOK_post_status_get_def) (defType retVal___, struct block_list *bl); +typedef unsigned short (*HPMHOOK_pre_status_get_speed) (struct block_list **bl); +typedef unsigned short (*HPMHOOK_post_status_get_speed) (unsigned short retVal___, struct block_list *bl); +typedef unsigned char (*HPMHOOK_pre_status_calc_attack_element) (struct block_list **bl, struct status_change **sc, int *element); +typedef unsigned char (*HPMHOOK_post_status_calc_attack_element) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element); +typedef int (*HPMHOOK_pre_status_get_party_id) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_party_id) (int retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_guild_id) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_guild_id) (int retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_emblem_id) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_emblem_id) (int retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_mexp) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_mexp) (int retVal___, const struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_race2) (const struct block_list **bl); +typedef int (*HPMHOOK_post_status_get_race2) (int retVal___, const struct block_list *bl); +typedef struct view_data* (*HPMHOOK_pre_status_get_viewdata) (struct block_list **bl); +typedef struct view_data* (*HPMHOOK_post_status_get_viewdata) (struct view_data* retVal___, struct block_list *bl); +typedef void (*HPMHOOK_pre_status_set_viewdata) (struct block_list **bl, int *class_); +typedef void (*HPMHOOK_post_status_set_viewdata) (struct block_list *bl, int class_); +typedef void (*HPMHOOK_pre_status_change_init) (struct block_list **bl); +typedef void (*HPMHOOK_post_status_change_init) (struct block_list *bl); +typedef struct status_change* (*HPMHOOK_pre_status_get_sc) (struct block_list **bl); +typedef struct status_change* (*HPMHOOK_post_status_get_sc) (struct status_change* retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_status_isdead) (struct block_list **bl); +typedef int (*HPMHOOK_post_status_isdead) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_status_isimmune) (struct block_list **bl); +typedef int (*HPMHOOK_post_status_isimmune) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_status_get_sc_def) (struct block_list **src, struct block_list **bl, enum sc_type *type, int *rate, int *tick, int *flag); +typedef int (*HPMHOOK_post_status_get_sc_def) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int tick, int flag); +typedef int (*HPMHOOK_pre_status_change_start) (struct block_list **src, struct block_list **bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag); +typedef int (*HPMHOOK_post_status_change_start) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int val1, int val2, int val3, int val4, int tick, int flag); +typedef int (*HPMHOOK_pre_status_change_end_) (struct block_list **bl, enum sc_type *type, int *tid, const char **file, int *line); +typedef int (*HPMHOOK_post_status_change_end_) (int retVal___, struct block_list *bl, enum sc_type type, int tid, const char *file, int line); +typedef int (*HPMHOOK_pre_status_kaahi_heal_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_status_kaahi_heal_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_status_change_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_status_change_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_status_change_timer_sub) (struct block_list **bl, va_list ap); +typedef int (*HPMHOOK_post_status_change_timer_sub) (int retVal___, struct block_list *bl, va_list ap); +typedef int (*HPMHOOK_pre_status_change_clear) (struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_status_change_clear) (int retVal___, struct block_list *bl, int type); +typedef int (*HPMHOOK_pre_status_change_clear_buffs) (struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_status_change_clear_buffs) (int retVal___, struct block_list *bl, int type); +typedef void (*HPMHOOK_pre_status_calc_bl_) (struct block_list **bl, enum scb_flag *flag, enum e_status_calc_opt *opt); +typedef void (*HPMHOOK_post_status_calc_bl_) (struct block_list *bl, enum scb_flag flag, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_mob_) (struct mob_data **md, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_mob_) (int retVal___, struct mob_data *md, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_pet_) (struct pet_data **pd, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_pet_) (int retVal___, struct pet_data *pd, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_pc_) (struct map_session_data **sd, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_pc_) (int retVal___, struct map_session_data *sd, enum e_status_calc_opt opt); +typedef void (*HPMHOOK_pre_status_calc_pc_additional) (struct map_session_data **sd, enum e_status_calc_opt *opt); +typedef void (*HPMHOOK_post_status_calc_pc_additional) (struct map_session_data *sd, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_homunculus_) (struct homun_data **hd, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_homunculus_) (int retVal___, struct homun_data *hd, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_mercenary_) (struct mercenary_data **md, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_mercenary_) (int retVal___, struct mercenary_data *md, enum e_status_calc_opt opt); +typedef int (*HPMHOOK_pre_status_calc_elemental_) (struct elemental_data **ed, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_elemental_) (int retVal___, struct elemental_data *ed, enum e_status_calc_opt opt); +typedef void (*HPMHOOK_pre_status_calc_misc) (struct block_list **bl, struct status_data **st, int *level); +typedef void (*HPMHOOK_post_status_calc_misc) (struct block_list *bl, struct status_data *st, int level); +typedef void (*HPMHOOK_pre_status_calc_regen) (struct block_list **bl, struct status_data **st, struct regen_data **regen); +typedef void (*HPMHOOK_post_status_calc_regen) (struct block_list *bl, struct status_data *st, struct regen_data *regen); +typedef void (*HPMHOOK_pre_status_calc_regen_rate) (struct block_list **bl, struct regen_data **regen, struct status_change **sc); +typedef void (*HPMHOOK_post_status_calc_regen_rate) (struct block_list *bl, struct regen_data *regen, struct status_change *sc); +typedef int (*HPMHOOK_pre_status_check_skilluse) (struct block_list **src, struct block_list **target, uint16 *skill_id, int *flag); +typedef int (*HPMHOOK_post_status_check_skilluse) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, int flag); +typedef int (*HPMHOOK_pre_status_check_visibility) (struct block_list **src, struct block_list **target); +typedef int (*HPMHOOK_post_status_check_visibility) (int retVal___, struct block_list *src, struct block_list *target); +typedef int (*HPMHOOK_pre_status_change_spread) (struct block_list **src, struct block_list **bl); +typedef int (*HPMHOOK_post_status_change_spread) (int retVal___, struct block_list *src, struct block_list *bl); +typedef defType (*HPMHOOK_pre_status_calc_def) (struct block_list **bl, struct status_change **sc, int *def, bool *viewable); +typedef defType (*HPMHOOK_post_status_calc_def) (defType retVal___, struct block_list *bl, struct status_change *sc, int def, bool viewable); +typedef short (*HPMHOOK_pre_status_calc_def2) (struct block_list **bl, struct status_change **sc, int *def2, bool *viewable); +typedef short (*HPMHOOK_post_status_calc_def2) (short retVal___, struct block_list *bl, struct status_change *sc, int def2, bool viewable); +typedef defType (*HPMHOOK_pre_status_calc_mdef) (struct block_list **bl, struct status_change **sc, int *mdef, bool *viewable); +typedef defType (*HPMHOOK_post_status_calc_mdef) (defType retVal___, struct block_list *bl, struct status_change *sc, int mdef, bool viewable); +typedef short (*HPMHOOK_pre_status_calc_mdef2) (struct block_list **bl, struct status_change **sc, int *mdef2, bool *viewable); +typedef short (*HPMHOOK_post_status_calc_mdef2) (short retVal___, struct block_list *bl, struct status_change *sc, int mdef2, bool viewable); +typedef unsigned short (*HPMHOOK_pre_status_calc_batk) (struct block_list **bl, struct status_change **sc, int *batk, bool *viewable); +typedef unsigned short (*HPMHOOK_post_status_calc_batk) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int batk, bool viewable); +typedef unsigned short (*HPMHOOK_pre_status_base_matk) (struct block_list **bl, const struct status_data **st, int *level); +typedef unsigned short (*HPMHOOK_post_status_base_matk) (unsigned short retVal___, struct block_list *bl, const struct status_data *st, int level); +typedef int (*HPMHOOK_pre_status_get_weapon_atk) (struct block_list **src, struct weapon_atk **watk, int *flag); +typedef int (*HPMHOOK_post_status_get_weapon_atk) (int retVal___, struct block_list *src, struct weapon_atk *watk, int flag); +typedef int (*HPMHOOK_pre_status_get_total_mdef) (struct block_list **src); +typedef int (*HPMHOOK_post_status_get_total_mdef) (int retVal___, struct block_list *src); +typedef int (*HPMHOOK_pre_status_get_total_def) (struct block_list **src); +typedef int (*HPMHOOK_post_status_get_total_def) (int retVal___, struct block_list *src); +typedef int (*HPMHOOK_pre_status_get_matk) (struct block_list **src, int *flag); +typedef int (*HPMHOOK_post_status_get_matk) (int retVal___, struct block_list *src, int flag); +typedef void (*HPMHOOK_pre_status_update_matk) (struct block_list **bl); +typedef void (*HPMHOOK_post_status_update_matk) (struct block_list *bl); +typedef int (*HPMHOOK_pre_status_readdb) (void); +typedef int (*HPMHOOK_post_status_readdb) (int retVal___); +typedef void (*HPMHOOK_pre_status_initChangeTables) (void); +typedef void (*HPMHOOK_post_status_initChangeTables) (void); +typedef void (*HPMHOOK_pre_status_initDummyData) (void); +typedef void (*HPMHOOK_post_status_initDummyData) (void); +typedef int (*HPMHOOK_pre_status_base_amotion_pc) (struct map_session_data **sd, struct status_data **st); +typedef int (*HPMHOOK_post_status_base_amotion_pc) (int retVal___, struct map_session_data *sd, struct status_data *st); +typedef unsigned short (*HPMHOOK_pre_status_base_atk) (const struct block_list **bl, const struct status_data **st); +typedef unsigned short (*HPMHOOK_post_status_base_atk) (unsigned short retVal___, const struct block_list *bl, const struct status_data *st); +typedef unsigned int (*HPMHOOK_pre_status_get_base_maxhp) (const struct map_session_data **sd, const struct status_data **st); +typedef unsigned int (*HPMHOOK_post_status_get_base_maxhp) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st); +typedef unsigned int (*HPMHOOK_pre_status_get_base_maxsp) (const struct map_session_data **sd, const struct status_data **st); +typedef unsigned int (*HPMHOOK_post_status_get_base_maxsp) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st); +typedef int (*HPMHOOK_pre_status_calc_npc_) (struct npc_data **nd, enum e_status_calc_opt *opt); +typedef int (*HPMHOOK_post_status_calc_npc_) (int retVal___, struct npc_data *nd, enum e_status_calc_opt opt); +typedef unsigned short (*HPMHOOK_pre_status_calc_str) (struct block_list **bl, struct status_change **sc, int *str); +typedef unsigned short (*HPMHOOK_post_status_calc_str) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int str); +typedef unsigned short (*HPMHOOK_pre_status_calc_agi) (struct block_list **bl, struct status_change **sc, int *agi); +typedef unsigned short (*HPMHOOK_post_status_calc_agi) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int agi); +typedef unsigned short (*HPMHOOK_pre_status_calc_vit) (struct block_list **bl, struct status_change **sc, int *vit); +typedef unsigned short (*HPMHOOK_post_status_calc_vit) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int vit); +typedef unsigned short (*HPMHOOK_pre_status_calc_int) (struct block_list **bl, struct status_change **sc, int *int_); +typedef unsigned short (*HPMHOOK_post_status_calc_int) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int int_); +typedef unsigned short (*HPMHOOK_pre_status_calc_dex) (struct block_list **bl, struct status_change **sc, int *dex); +typedef unsigned short (*HPMHOOK_post_status_calc_dex) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dex); +typedef unsigned short (*HPMHOOK_pre_status_calc_luk) (struct block_list **bl, struct status_change **sc, int *luk); +typedef unsigned short (*HPMHOOK_post_status_calc_luk) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int luk); +typedef unsigned short (*HPMHOOK_pre_status_calc_watk) (struct block_list **bl, struct status_change **sc, int *watk, bool *viewable); +typedef unsigned short (*HPMHOOK_post_status_calc_watk) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int watk, bool viewable); +typedef unsigned short (*HPMHOOK_pre_status_calc_matk) (struct block_list **bl, struct status_change **sc, int *matk, bool *viewable); +typedef unsigned short (*HPMHOOK_post_status_calc_matk) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk, bool viewable); +typedef signed short (*HPMHOOK_pre_status_calc_hit) (struct block_list **bl, struct status_change **sc, int *hit, bool *viewable); +typedef signed short (*HPMHOOK_post_status_calc_hit) (signed short retVal___, struct block_list *bl, struct status_change *sc, int hit, bool viewable); +typedef signed short (*HPMHOOK_pre_status_calc_critical) (struct block_list **bl, struct status_change **sc, int *critical, bool *viewable); +typedef signed short (*HPMHOOK_post_status_calc_critical) (signed short retVal___, struct block_list *bl, struct status_change *sc, int critical, bool viewable); +typedef signed short (*HPMHOOK_pre_status_calc_flee) (struct block_list **bl, struct status_change **sc, int *flee, bool *viewable); +typedef signed short (*HPMHOOK_post_status_calc_flee) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee, bool viewable); +typedef signed short (*HPMHOOK_pre_status_calc_flee2) (struct block_list **bl, struct status_change **sc, int *flee2, bool *viewable); +typedef signed short (*HPMHOOK_post_status_calc_flee2) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee2, bool viewable); +typedef unsigned short (*HPMHOOK_pre_status_calc_speed) (struct block_list **bl, struct status_change **sc, int *speed); +typedef unsigned short (*HPMHOOK_post_status_calc_speed) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int speed); +typedef short (*HPMHOOK_pre_status_calc_aspd_rate) (struct block_list **bl, struct status_change **sc, int *aspd_rate); +typedef short (*HPMHOOK_post_status_calc_aspd_rate) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd_rate); +typedef unsigned short (*HPMHOOK_pre_status_calc_dmotion) (struct block_list **bl, struct status_change **sc, int *dmotion); +typedef unsigned short (*HPMHOOK_post_status_calc_dmotion) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dmotion); +typedef short (*HPMHOOK_pre_status_calc_aspd) (struct block_list **bl, struct status_change **sc, short *flag); +typedef short (*HPMHOOK_post_status_calc_aspd) (short retVal___, struct block_list *bl, struct status_change *sc, short flag); +typedef short (*HPMHOOK_pre_status_calc_fix_aspd) (struct block_list **bl, struct status_change **sc, int *aspd); +typedef short (*HPMHOOK_post_status_calc_fix_aspd) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd); +typedef unsigned int (*HPMHOOK_pre_status_calc_maxhp) (struct block_list **bl, struct status_change **sc, uint64 *maxhp); +typedef unsigned int (*HPMHOOK_post_status_calc_maxhp) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, uint64 maxhp); +typedef unsigned int (*HPMHOOK_pre_status_calc_maxsp) (struct block_list **bl, struct status_change **sc, unsigned int *maxsp); +typedef unsigned int (*HPMHOOK_post_status_calc_maxsp) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, unsigned int maxsp); +typedef unsigned char (*HPMHOOK_pre_status_calc_element) (struct block_list **bl, struct status_change **sc, int *element); +typedef unsigned char (*HPMHOOK_post_status_calc_element) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element); +typedef unsigned char (*HPMHOOK_pre_status_calc_element_lv) (struct block_list **bl, struct status_change **sc, int *lv); +typedef unsigned char (*HPMHOOK_post_status_calc_element_lv) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int lv); +typedef uint32 (*HPMHOOK_pre_status_calc_mode) (const struct block_list **bl, const struct status_change **sc, uint32 *mode); +typedef uint32 (*HPMHOOK_post_status_calc_mode) (uint32 retVal___, const struct block_list *bl, const struct status_change *sc, uint32 mode); +typedef unsigned short (*HPMHOOK_pre_status_calc_ematk) (struct block_list **bl, struct status_change **sc, int *matk); +typedef unsigned short (*HPMHOOK_post_status_calc_ematk) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk); +typedef void (*HPMHOOK_pre_status_calc_bl_main) (struct block_list **bl, int *flag); +typedef void (*HPMHOOK_post_status_calc_bl_main) (struct block_list *bl, int flag); +typedef void (*HPMHOOK_pre_status_display_add) (struct map_session_data **sd, enum sc_type *type, int *dval1, int *dval2, int *dval3); +typedef void (*HPMHOOK_post_status_display_add) (struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3); +typedef void (*HPMHOOK_pre_status_display_remove) (struct map_session_data **sd, enum sc_type *type); +typedef void (*HPMHOOK_post_status_display_remove) (struct map_session_data *sd, enum sc_type type); +typedef int (*HPMHOOK_pre_status_natural_heal) (struct block_list **bl, va_list args); +typedef int (*HPMHOOK_post_status_natural_heal) (int retVal___, struct block_list *bl, va_list args); +typedef int (*HPMHOOK_pre_status_natural_heal_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_status_natural_heal_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef bool (*HPMHOOK_pre_status_readdb_job2) (char **fields[], int *columns, int *current); +typedef bool (*HPMHOOK_post_status_readdb_job2) (bool retVal___, char *fields[], int columns, int current); +typedef bool (*HPMHOOK_pre_status_readdb_sizefix) (char **fields[], int *columns, int *current); +typedef bool (*HPMHOOK_post_status_readdb_sizefix) (bool retVal___, char *fields[], int columns, int current); +typedef int (*HPMHOOK_pre_status_readdb_refine_libconfig) (const char **filename); +typedef int (*HPMHOOK_post_status_readdb_refine_libconfig) (int retVal___, const char *filename); +typedef int (*HPMHOOK_pre_status_readdb_refine_libconfig_sub) (struct config_setting_t **r, const char **name, const char **source); +typedef int (*HPMHOOK_post_status_readdb_refine_libconfig_sub) (int retVal___, struct config_setting_t *r, const char *name, const char *source); +typedef bool (*HPMHOOK_pre_status_readdb_scconfig) (char **fields[], int *columns, int *current); +typedef bool (*HPMHOOK_post_status_readdb_scconfig) (bool retVal___, char *fields[], int columns, int current); +typedef void (*HPMHOOK_pre_status_read_job_db) (void); +typedef void (*HPMHOOK_post_status_read_job_db) (void); +typedef void (*HPMHOOK_pre_status_read_job_db_sub) (int *idx, const char **name, struct config_setting_t **jdb); +typedef void (*HPMHOOK_post_status_read_job_db_sub) (int idx, const char *name, struct config_setting_t *jdb); +typedef void (*HPMHOOK_pre_status_set_sc) (uint16 *skill_id, sc_type *sc, int *icon, unsigned int *flag); +typedef void (*HPMHOOK_post_status_set_sc) (uint16 skill_id, sc_type sc, int icon, unsigned int flag); +typedef void (*HPMHOOK_pre_status_copy) (struct status_data **a, const struct status_data **b); +typedef void (*HPMHOOK_post_status_copy) (struct status_data *a, const struct status_data *b); +typedef unsigned short (*HPMHOOK_pre_status_base_matk_min) (const struct status_data **st); +typedef unsigned short (*HPMHOOK_post_status_base_matk_min) (unsigned short retVal___, const struct status_data *st); +typedef unsigned short (*HPMHOOK_pre_status_base_matk_max) (const struct status_data **st); +typedef unsigned short (*HPMHOOK_post_status_base_matk_max) (unsigned short retVal___, const struct status_data *st); +#endif // MAP_STATUS_H +#ifdef MAP_STORAGE_H /* storage */ +typedef void (*HPMHOOK_pre_storage_reconnect) (void); +typedef void (*HPMHOOK_post_storage_reconnect) (void); +typedef int (*HPMHOOK_pre_storage_delitem) (struct map_session_data **sd, int *n, int *amount); +typedef int (*HPMHOOK_post_storage_delitem) (int retVal___, struct map_session_data *sd, int n, int amount); +typedef int (*HPMHOOK_pre_storage_open) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_storage_open) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_storage_add) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_storage_add) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_storage_get) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_storage_get) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_storage_additem) (struct map_session_data **sd, struct item **item_data, int *amount); +typedef int (*HPMHOOK_post_storage_additem) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount); +typedef int (*HPMHOOK_pre_storage_addfromcart) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_storage_addfromcart) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef int (*HPMHOOK_pre_storage_gettocart) (struct map_session_data **sd, int *index, int *amount); +typedef int (*HPMHOOK_post_storage_gettocart) (int retVal___, struct map_session_data *sd, int index, int amount); +typedef void (*HPMHOOK_pre_storage_close) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_storage_close) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_storage_pc_quit) (struct map_session_data **sd, int *flag); +typedef void (*HPMHOOK_post_storage_pc_quit) (struct map_session_data *sd, int flag); +typedef int (*HPMHOOK_pre_storage_comp_item) (const void **i1_, const void **i2_); +typedef int (*HPMHOOK_post_storage_comp_item) (int retVal___, const void *i1_, const void *i2_); +typedef void (*HPMHOOK_pre_storage_sortitem) (struct item **items, unsigned int *size); +typedef void (*HPMHOOK_post_storage_sortitem) (struct item *items, unsigned int size); +typedef int (*HPMHOOK_pre_storage_reconnect_sub) (union DBKey *key, struct DBData **data, va_list ap); +typedef int (*HPMHOOK_post_storage_reconnect_sub) (int retVal___, union DBKey key, struct DBData *data, va_list ap); +#endif // MAP_STORAGE_H +#ifdef COMMON_STRLIB_H /* StrBuf */ +typedef StringBuf* (*HPMHOOK_pre_StrBuf_Malloc) (void); +typedef StringBuf* (*HPMHOOK_post_StrBuf_Malloc) (StringBuf* retVal___); +typedef void (*HPMHOOK_pre_StrBuf_Init) (StringBuf **self); +typedef void (*HPMHOOK_post_StrBuf_Init) (StringBuf *self); +typedef int (*HPMHOOK_pre_StrBuf_Vprintf) (StringBuf **self, const char **fmt, va_list args); +typedef int (*HPMHOOK_post_StrBuf_Vprintf) (int retVal___, StringBuf *self, const char *fmt, va_list args); +typedef int (*HPMHOOK_pre_StrBuf_Append) (StringBuf **self, const StringBuf **sbuf); +typedef int (*HPMHOOK_post_StrBuf_Append) (int retVal___, StringBuf *self, const StringBuf *sbuf); +typedef int (*HPMHOOK_pre_StrBuf_AppendStr) (StringBuf **self, const char **str); +typedef int (*HPMHOOK_post_StrBuf_AppendStr) (int retVal___, StringBuf *self, const char *str); +typedef int (*HPMHOOK_pre_StrBuf_Length) (StringBuf **self); +typedef int (*HPMHOOK_post_StrBuf_Length) (int retVal___, StringBuf *self); +typedef char* (*HPMHOOK_pre_StrBuf_Value) (StringBuf **self); +typedef char* (*HPMHOOK_post_StrBuf_Value) (char* retVal___, StringBuf *self); +typedef void (*HPMHOOK_pre_StrBuf_Clear) (StringBuf **self); +typedef void (*HPMHOOK_post_StrBuf_Clear) (StringBuf *self); +typedef void (*HPMHOOK_pre_StrBuf_Destroy) (StringBuf **self); +typedef void (*HPMHOOK_post_StrBuf_Destroy) (StringBuf *self); +typedef void (*HPMHOOK_pre_StrBuf_Free) (StringBuf **self); +typedef void (*HPMHOOK_post_StrBuf_Free) (StringBuf *self); +#endif // COMMON_STRLIB_H +#ifdef COMMON_STRLIB_H /* strlib */ +typedef char* (*HPMHOOK_pre_strlib_jstrescape) (char **pt); +typedef char* (*HPMHOOK_post_strlib_jstrescape) (char* retVal___, char *pt); +typedef char* (*HPMHOOK_pre_strlib_jstrescapecpy) (char **pt, const char **spt); +typedef char* (*HPMHOOK_post_strlib_jstrescapecpy) (char* retVal___, char *pt, const char *spt); +typedef int (*HPMHOOK_pre_strlib_jmemescapecpy) (char **pt, const char **spt, int *size); +typedef int (*HPMHOOK_post_strlib_jmemescapecpy) (int retVal___, char *pt, const char *spt, int size); +typedef int (*HPMHOOK_pre_strlib_remove_control_chars_) (char **str); +typedef int (*HPMHOOK_post_strlib_remove_control_chars_) (int retVal___, char *str); +typedef char* (*HPMHOOK_pre_strlib_trim_) (char **str); +typedef char* (*HPMHOOK_post_strlib_trim_) (char* retVal___, char *str); +typedef char* (*HPMHOOK_pre_strlib_normalize_name_) (char **str, const char **delims); +typedef char* (*HPMHOOK_post_strlib_normalize_name_) (char* retVal___, char *str, const char *delims); +typedef const char* (*HPMHOOK_pre_strlib_stristr_) (const char **haystack, const char **needle); +typedef const char* (*HPMHOOK_post_strlib_stristr_) (const char* retVal___, const char *haystack, const char *needle); +typedef size_t (*HPMHOOK_pre_strlib_strnlen_) (const char **string, size_t *maxlen); +typedef size_t (*HPMHOOK_post_strlib_strnlen_) (size_t retVal___, const char *string, size_t maxlen); +typedef char* (*HPMHOOK_pre_strlib_strtok_r_) (char **s1, const char **s2, char ***lasts); +typedef char* (*HPMHOOK_post_strlib_strtok_r_) (char* retVal___, char *s1, const char *s2, char **lasts); +typedef int (*HPMHOOK_pre_strlib_e_mail_check_) (char **email); +typedef int (*HPMHOOK_post_strlib_e_mail_check_) (int retVal___, char *email); +typedef int (*HPMHOOK_pre_strlib_config_switch_) (const char **str); +typedef int (*HPMHOOK_post_strlib_config_switch_) (int retVal___, const char *str); +typedef char* (*HPMHOOK_pre_strlib_safestrncpy_) (char **dst, const char **src, size_t *n); +typedef char* (*HPMHOOK_post_strlib_safestrncpy_) (char* retVal___, char *dst, const char *src, size_t n); +typedef size_t (*HPMHOOK_pre_strlib_safestrnlen_) (const char **string, size_t *maxlen); +typedef size_t (*HPMHOOK_post_strlib_safestrnlen_) (size_t retVal___, const char *string, size_t maxlen); +typedef int (*HPMHOOK_pre_strlib_strline_) (const char **str, size_t *pos); +typedef int (*HPMHOOK_post_strlib_strline_) (int retVal___, const char *str, size_t pos); +typedef bool (*HPMHOOK_pre_strlib_bin2hex_) (char **output, const unsigned char **input, size_t *count); +typedef bool (*HPMHOOK_post_strlib_bin2hex_) (bool retVal___, char *output, const unsigned char *input, size_t count); +#endif // COMMON_STRLIB_H +#ifdef COMMON_STRLIB_H /* sv */ +typedef int (*HPMHOOK_pre_sv_parse_next) (struct s_svstate **svstate); +typedef int (*HPMHOOK_post_sv_parse_next) (int retVal___, struct s_svstate *svstate); +typedef int (*HPMHOOK_pre_sv_parse) (const char **str, int *len, int *startoff, char *delim, int **out_pos, int *npos, enum e_svopt *opt); +typedef int (*HPMHOOK_post_sv_parse) (int retVal___, const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt); +typedef int (*HPMHOOK_pre_sv_split) (char **str, int *len, int *startoff, char *delim, char ***out_fields, int *nfields, enum e_svopt *opt); +typedef int (*HPMHOOK_post_sv_split) (int retVal___, char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt); +typedef size_t (*HPMHOOK_pre_sv_escape_c) (char **out_dest, const char **src, size_t *len, const char **escapes); +typedef size_t (*HPMHOOK_post_sv_escape_c) (size_t retVal___, char *out_dest, const char *src, size_t len, const char *escapes); +typedef size_t (*HPMHOOK_pre_sv_unescape_c) (char **out_dest, const char **src, size_t *len); +typedef size_t (*HPMHOOK_post_sv_unescape_c) (size_t retVal___, char *out_dest, const char *src, size_t len); +typedef const char* (*HPMHOOK_pre_sv_skip_escaped_c) (const char **p); +typedef const char* (*HPMHOOK_post_sv_skip_escaped_c) (const char* retVal___, const char *p); +typedef bool (*HPMHOOK_pre_sv_readdb) (const char **directory, const char **filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( **parseproc ) (char *fields[], int columns, int current)); +typedef bool (*HPMHOOK_post_sv_readdb) (bool retVal___, const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); +#endif // COMMON_STRLIB_H +#ifdef COMMON_SYSINFO_H /* sysinfo */ +typedef int (*HPMHOOK_pre_sysinfo_getpagesize) (void); +typedef int (*HPMHOOK_post_sysinfo_getpagesize) (int retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_platform) (void); +typedef const char* (*HPMHOOK_post_sysinfo_platform) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_osversion) (void); +typedef const char* (*HPMHOOK_post_sysinfo_osversion) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_cpu) (void); +typedef const char* (*HPMHOOK_post_sysinfo_cpu) (const char* retVal___); +typedef int (*HPMHOOK_pre_sysinfo_cpucores) (void); +typedef int (*HPMHOOK_post_sysinfo_cpucores) (int retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_arch) (void); +typedef const char* (*HPMHOOK_post_sysinfo_arch) (const char* retVal___); +typedef bool (*HPMHOOK_pre_sysinfo_is64bit) (void); +typedef bool (*HPMHOOK_post_sysinfo_is64bit) (bool retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_compiler) (void); +typedef const char* (*HPMHOOK_post_sysinfo_compiler) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_cflags) (void); +typedef const char* (*HPMHOOK_post_sysinfo_cflags) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_time) (void); +typedef const char* (*HPMHOOK_post_sysinfo_time) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_vcstype) (void); +typedef const char* (*HPMHOOK_post_sysinfo_vcstype) (const char* retVal___); +typedef int (*HPMHOOK_pre_sysinfo_vcstypeid) (void); +typedef int (*HPMHOOK_post_sysinfo_vcstypeid) (int retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_vcsrevision_src) (void); +typedef const char* (*HPMHOOK_post_sysinfo_vcsrevision_src) (const char* retVal___); +typedef const char* (*HPMHOOK_pre_sysinfo_vcsrevision_scripts) (void); +typedef const char* (*HPMHOOK_post_sysinfo_vcsrevision_scripts) (const char* retVal___); +typedef void (*HPMHOOK_pre_sysinfo_vcsrevision_reload) (void); +typedef void (*HPMHOOK_post_sysinfo_vcsrevision_reload) (void); +typedef bool (*HPMHOOK_pre_sysinfo_is_superuser) (void); +typedef bool (*HPMHOOK_post_sysinfo_is_superuser) (bool retVal___); +typedef void (*HPMHOOK_pre_sysinfo_init) (void); +typedef void (*HPMHOOK_post_sysinfo_init) (void); +typedef void (*HPMHOOK_pre_sysinfo_final) (void); +typedef void (*HPMHOOK_post_sysinfo_final) (void); +#endif // COMMON_SYSINFO_H +#ifdef COMMON_TIMER_H /* timer */ +typedef int64 (*HPMHOOK_pre_timer_gettick) (void); +typedef int64 (*HPMHOOK_post_timer_gettick) (int64 retVal___); +typedef int64 (*HPMHOOK_pre_timer_gettick_nocache) (void); +typedef int64 (*HPMHOOK_post_timer_gettick_nocache) (int64 retVal___); +typedef int (*HPMHOOK_pre_timer_add) (int64 *tick, TimerFunc *func, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_timer_add) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data); +typedef int (*HPMHOOK_pre_timer_add_interval) (int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); +typedef int (*HPMHOOK_post_timer_add_interval) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data, int interval); +typedef const struct TimerData* (*HPMHOOK_pre_timer_get) (int *tid); +typedef const struct TimerData* (*HPMHOOK_post_timer_get) (const struct TimerData* retVal___, int tid); +typedef int (*HPMHOOK_pre_timer_delete) (int *tid, TimerFunc *func); +typedef int (*HPMHOOK_post_timer_delete) (int retVal___, int tid, TimerFunc func); +typedef int64 (*HPMHOOK_pre_timer_addtick) (int *tid, int64 *tick); +typedef int64 (*HPMHOOK_post_timer_addtick) (int64 retVal___, int tid, int64 tick); +typedef int64 (*HPMHOOK_pre_timer_settick) (int *tid, int64 *tick); +typedef int64 (*HPMHOOK_post_timer_settick) (int64 retVal___, int tid, int64 tick); +typedef int (*HPMHOOK_pre_timer_add_func_list) (TimerFunc *func, char **name); +typedef int (*HPMHOOK_post_timer_add_func_list) (int retVal___, TimerFunc func, char *name); +typedef unsigned long (*HPMHOOK_pre_timer_get_uptime) (void); +typedef unsigned long (*HPMHOOK_post_timer_get_uptime) (unsigned long retVal___); +typedef int (*HPMHOOK_pre_timer_perform) (int64 *tick); +typedef int (*HPMHOOK_post_timer_perform) (int retVal___, int64 tick); +typedef void (*HPMHOOK_pre_timer_init) (void); +typedef void (*HPMHOOK_post_timer_init) (void); +typedef void (*HPMHOOK_pre_timer_final) (void); +typedef void (*HPMHOOK_post_timer_final) (void); +#endif // COMMON_TIMER_H +#ifdef MAP_TRADE_H /* trade */ +typedef void (*HPMHOOK_pre_trade_request) (struct map_session_data **sd, struct map_session_data **target_sd); +typedef void (*HPMHOOK_post_trade_request) (struct map_session_data *sd, struct map_session_data *target_sd); +typedef void (*HPMHOOK_pre_trade_ack) (struct map_session_data **sd, int *type); +typedef void (*HPMHOOK_post_trade_ack) (struct map_session_data *sd, int type); +typedef int (*HPMHOOK_pre_trade_check_impossible) (struct map_session_data **sd); +typedef int (*HPMHOOK_post_trade_check_impossible) (int retVal___, struct map_session_data *sd); +typedef int (*HPMHOOK_pre_trade_check) (struct map_session_data **sd, struct map_session_data **tsd); +typedef int (*HPMHOOK_post_trade_check) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd); +typedef void (*HPMHOOK_pre_trade_additem) (struct map_session_data **sd, short *index, short *amount); +typedef void (*HPMHOOK_post_trade_additem) (struct map_session_data *sd, short index, short amount); +typedef void (*HPMHOOK_pre_trade_addzeny) (struct map_session_data **sd, int *amount); +typedef void (*HPMHOOK_post_trade_addzeny) (struct map_session_data *sd, int amount); +typedef void (*HPMHOOK_pre_trade_ok) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_trade_ok) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_trade_cancel) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_trade_cancel) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_trade_commit) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_trade_commit) (struct map_session_data *sd); +#endif // MAP_TRADE_H +#ifdef MAP_UNIT_H /* unit */ +typedef int (*HPMHOOK_pre_unit_init) (bool *minimal); +typedef int (*HPMHOOK_post_unit_init) (int retVal___, bool minimal); +typedef int (*HPMHOOK_pre_unit_final) (void); +typedef int (*HPMHOOK_post_unit_final) (int retVal___); +typedef struct unit_data* (*HPMHOOK_pre_unit_bl2ud) (struct block_list **bl); +typedef struct unit_data* (*HPMHOOK_post_unit_bl2ud) (struct unit_data* retVal___, struct block_list *bl); +typedef struct unit_data* (*HPMHOOK_pre_unit_bl2ud2) (struct block_list **bl); +typedef struct unit_data* (*HPMHOOK_post_unit_bl2ud2) (struct unit_data* retVal___, struct block_list *bl); +typedef void (*HPMHOOK_pre_unit_init_ud) (struct unit_data **ud); +typedef void (*HPMHOOK_post_unit_init_ud) (struct unit_data *ud); +typedef int (*HPMHOOK_pre_unit_attack_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_attack_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_unit_walktoxy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_walktoxy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_unit_walktoxy_sub) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_walktoxy_sub) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_delay_walktoxy_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_delay_walktoxy_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_unit_walktoxy) (struct block_list **bl, short *x, short *y, int *flag); +typedef int (*HPMHOOK_post_unit_walktoxy) (int retVal___, struct block_list *bl, short x, short y, int flag); +typedef int (*HPMHOOK_pre_unit_walktobl_sub) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_walktobl_sub) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_unit_walktobl) (struct block_list **bl, struct block_list **tbl, int *range, int *flag); +typedef int (*HPMHOOK_post_unit_walktobl) (int retVal___, struct block_list *bl, struct block_list *tbl, int range, int flag); +typedef bool (*HPMHOOK_pre_unit_run) (struct block_list **bl, struct map_session_data **sd, enum sc_type *type); +typedef bool (*HPMHOOK_post_unit_run) (bool retVal___, struct block_list *bl, struct map_session_data *sd, enum sc_type type); +typedef void (*HPMHOOK_pre_unit_run_hit) (struct block_list **bl, struct status_change **sc, struct map_session_data **sd, enum sc_type *type); +typedef void (*HPMHOOK_post_unit_run_hit) (struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type type); +typedef int (*HPMHOOK_pre_unit_escape) (struct block_list **bl, struct block_list **target, short *dist); +typedef int (*HPMHOOK_post_unit_escape) (int retVal___, struct block_list *bl, struct block_list *target, short dist); +typedef int (*HPMHOOK_pre_unit_movepos) (struct block_list **bl, short *dst_x, short *dst_y, int *easy, bool *checkpath); +typedef int (*HPMHOOK_post_unit_movepos) (int retVal___, struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath); +typedef int (*HPMHOOK_pre_unit_setdir) (struct block_list **bl, unsigned char *dir); +typedef int (*HPMHOOK_post_unit_setdir) (int retVal___, struct block_list *bl, unsigned char dir); +typedef uint8 (*HPMHOOK_pre_unit_getdir) (struct block_list **bl); +typedef uint8 (*HPMHOOK_post_unit_getdir) (uint8 retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_blown) (struct block_list **bl, int *dx, int *dy, int *count, int *flag); +typedef int (*HPMHOOK_post_unit_blown) (int retVal___, struct block_list *bl, int dx, int dy, int count, int flag); +typedef int (*HPMHOOK_pre_unit_warp) (struct block_list **bl, short *m, short *x, short *y, clr_type *type); +typedef int (*HPMHOOK_post_unit_warp) (int retVal___, struct block_list *bl, short m, short x, short y, clr_type type); +typedef int (*HPMHOOK_pre_unit_stop_walking) (struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_unit_stop_walking) (int retVal___, struct block_list *bl, int type); +typedef int (*HPMHOOK_pre_unit_skilluse_id) (struct block_list **src, int *target_id, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_unit_skilluse_id) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_unit_step_timer) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_step_timer) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef void (*HPMHOOK_pre_unit_stop_stepaction) (struct block_list **bl); +typedef void (*HPMHOOK_post_unit_stop_stepaction) (struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_is_walking) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_is_walking) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_can_move) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_can_move) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_resume_running) (int *tid, int64 *tick, int *id, intptr_t *data); +typedef int (*HPMHOOK_post_unit_resume_running) (int retVal___, int tid, int64 tick, int id, intptr_t data); +typedef int (*HPMHOOK_pre_unit_set_walkdelay) (struct block_list **bl, int64 *tick, int *delay, int *type); +typedef int (*HPMHOOK_post_unit_set_walkdelay) (int retVal___, struct block_list *bl, int64 tick, int delay, int type); +typedef int (*HPMHOOK_pre_unit_skilluse_id2) (struct block_list **src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); +typedef int (*HPMHOOK_post_unit_skilluse_id2) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel); +typedef int (*HPMHOOK_pre_unit_skilluse_pos) (struct block_list **src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv); +typedef int (*HPMHOOK_post_unit_skilluse_pos) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv); +typedef int (*HPMHOOK_pre_unit_skilluse_pos2) (struct block_list **src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); +typedef int (*HPMHOOK_post_unit_skilluse_pos2) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel); +typedef int (*HPMHOOK_pre_unit_set_target) (struct unit_data **ud, int *target_id); +typedef int (*HPMHOOK_post_unit_set_target) (int retVal___, struct unit_data *ud, int target_id); +typedef void (*HPMHOOK_pre_unit_stop_attack) (struct block_list **bl); +typedef void (*HPMHOOK_post_unit_stop_attack) (struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_unattackable) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_unattackable) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_attack) (struct block_list **src, int *target_id, int *continuous); +typedef int (*HPMHOOK_post_unit_attack) (int retVal___, struct block_list *src, int target_id, int continuous); +typedef int (*HPMHOOK_pre_unit_cancel_combo) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_cancel_combo) (int retVal___, struct block_list *bl); +typedef bool (*HPMHOOK_pre_unit_can_reach_pos) (struct block_list **bl, int *x, int *y, int *easy); +typedef bool (*HPMHOOK_post_unit_can_reach_pos) (bool retVal___, struct block_list *bl, int x, int y, int easy); +typedef bool (*HPMHOOK_pre_unit_can_reach_bl) (struct block_list **bl, struct block_list **tbl, int *range, int *easy, short **x, short **y); +typedef bool (*HPMHOOK_post_unit_can_reach_bl) (bool retVal___, struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y); +typedef int (*HPMHOOK_pre_unit_calc_pos) (struct block_list **bl, int *tx, int *ty, uint8 *dir); +typedef int (*HPMHOOK_post_unit_calc_pos) (int retVal___, struct block_list *bl, int tx, int ty, uint8 dir); +typedef int (*HPMHOOK_pre_unit_attack_timer_sub) (struct block_list **src, int *tid, int64 *tick); +typedef int (*HPMHOOK_post_unit_attack_timer_sub) (int retVal___, struct block_list *src, int tid, int64 tick); +typedef int (*HPMHOOK_pre_unit_skillcastcancel) (struct block_list **bl, int *type); +typedef int (*HPMHOOK_post_unit_skillcastcancel) (int retVal___, struct block_list *bl, int type); +typedef void (*HPMHOOK_pre_unit_dataset) (struct block_list **bl); +typedef void (*HPMHOOK_post_unit_dataset) (struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_counttargeted) (struct block_list **bl); +typedef int (*HPMHOOK_post_unit_counttargeted) (int retVal___, struct block_list *bl); +typedef int (*HPMHOOK_pre_unit_fixdamage) (struct block_list **src, struct block_list **target, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); +typedef int (*HPMHOOK_post_unit_fixdamage) (int retVal___, struct block_list *src, struct block_list *target, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2); +typedef int (*HPMHOOK_pre_unit_changeviewsize) (struct block_list **bl, short *size); +typedef int (*HPMHOOK_post_unit_changeviewsize) (int retVal___, struct block_list *bl, short size); +typedef int (*HPMHOOK_pre_unit_remove_map) (struct block_list **bl, clr_type *clrtype, const char **file, int *line, const char **func); +typedef int (*HPMHOOK_post_unit_remove_map) (int retVal___, struct block_list *bl, clr_type clrtype, const char *file, int line, const char *func); +typedef void (*HPMHOOK_pre_unit_remove_map_pc) (struct map_session_data **sd, clr_type *clrtype); +typedef void (*HPMHOOK_post_unit_remove_map_pc) (struct map_session_data *sd, clr_type clrtype); +typedef void (*HPMHOOK_pre_unit_free_pc) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_unit_free_pc) (struct map_session_data *sd); +typedef int (*HPMHOOK_pre_unit_free) (struct block_list **bl, clr_type *clrtype); +typedef int (*HPMHOOK_post_unit_free) (int retVal___, struct block_list *bl, clr_type clrtype); +#endif // MAP_UNIT_H +#ifdef MAP_VENDING_H /* vending */ +typedef void (*HPMHOOK_pre_vending_init) (bool *minimal); +typedef void (*HPMHOOK_post_vending_init) (bool minimal); +typedef void (*HPMHOOK_pre_vending_final) (void); +typedef void (*HPMHOOK_post_vending_final) (void); +typedef void (*HPMHOOK_pre_vending_close) (struct map_session_data **sd); +typedef void (*HPMHOOK_post_vending_close) (struct map_session_data *sd); +typedef void (*HPMHOOK_pre_vending_open) (struct map_session_data **sd, const char **message, const uint8 **data, int *count); +typedef void (*HPMHOOK_post_vending_open) (struct map_session_data *sd, const char *message, const uint8 *data, int count); +typedef void (*HPMHOOK_pre_vending_list) (struct map_session_data **sd, unsigned int *id); +typedef void (*HPMHOOK_post_vending_list) (struct map_session_data *sd, unsigned int id); +typedef void (*HPMHOOK_pre_vending_purchase) (struct map_session_data **sd, int *aid, unsigned int *uid, const uint8 **data, int *count); +typedef void (*HPMHOOK_post_vending_purchase) (struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count); +typedef bool (*HPMHOOK_pre_vending_search) (struct map_session_data **sd, unsigned short *nameid); +typedef bool (*HPMHOOK_post_vending_search) (bool retVal___, struct map_session_data *sd, unsigned short nameid); +typedef bool (*HPMHOOK_pre_vending_searchall) (struct map_session_data **sd, const struct s_search_store_search **s); +typedef bool (*HPMHOOK_post_vending_searchall) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s); +#endif // MAP_VENDING_H diff --git a/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc index 7210920e5..3477a58a7 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.HPMHooksCore.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct { struct HPMHookPoint *HP_HCache_init_pre; struct HPMHookPoint *HP_HCache_init_post; diff --git a/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc index ab273a852..9844e61b6 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.HookingPoints.inc @@ -1,5 +1,6 @@ /** * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules * * Copyright (C) 2013-2016 Hercules Dev Team * @@ -22,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct HookingPointData HookingPoints[] = { /* HCache_interface */ { HP_POP(HCache->init, HP_HCache_init) }, diff --git a/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc index 04dc90c6c..b1f2f58b7 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.Hooks.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + /* HCache_interface */ void HP_HCache_init(void) { int hIndex = 0; @@ -54,11 +56,11 @@ bool HP_HCache_check(const char *file) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_HCache_check_pre ) { - bool (*preHookFunc) (const char *file); + bool (*preHookFunc) (const char **file); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; - retVal___ = preHookFunc(file); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -81,11 +83,11 @@ FILE* HP_HCache_open(const char *file, const char *opt) { int hIndex = 0; FILE* retVal___ = NULL; if( HPMHooks.count.HP_HCache_open_pre ) { - FILE* (*preHookFunc) (const char *file, const char *opt); + FILE* (*preHookFunc) (const char **file, const char **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; - retVal___ = preHookFunc(file, opt); + retVal___ = preHookFunc(&file, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -124,10 +126,10 @@ int HP_chr_waiting_disconnect(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chr.waiting_disconnect(tid, tick, id, data); } if( HPMHooks.count.HP_chr_waiting_disconnect_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_waiting_disconnect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_waiting_disconnect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -151,18 +153,17 @@ int HP_chr_delete_char_sql(int char_id) { retVal___ = HPMHooks.source.chr.delete_char_sql(char_id); } if( HPMHooks.count.HP_chr_delete_char_sql_post ) { - int (*postHookFunc) (int retVal___, int *char_id); + int (*postHookFunc) (int retVal___, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete_char_sql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete_char_sql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id); + retVal___ = postHookFunc(retVal___, char_id); } } return retVal___; } struct DBData HP_chr_create_online_char_data(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_chr_create_online_char_data_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -183,11 +184,11 @@ struct DBData HP_chr_create_online_char_data(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_chr_create_online_char_data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_create_online_char_data_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_chr_create_online_char_data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -211,10 +212,10 @@ void HP_chr_set_account_online(int account_id) { HPMHooks.source.chr.set_account_online(account_id); } if( HPMHooks.count.HP_chr_set_account_online_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_account_online_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_account_online_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -237,10 +238,10 @@ void HP_chr_set_account_offline(int account_id) { HPMHooks.source.chr.set_account_offline(account_id); } if( HPMHooks.count.HP_chr_set_account_offline_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_account_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_account_offline_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -263,10 +264,10 @@ void HP_chr_set_char_charselect(int account_id) { HPMHooks.source.chr.set_char_charselect(account_id); } if( HPMHooks.count.HP_chr_set_char_charselect_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_char_charselect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_char_charselect_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -289,10 +290,10 @@ void HP_chr_set_char_online(int map_id, int char_id, int account_id) { HPMHooks.source.chr.set_char_online(map_id, char_id, account_id); } if( HPMHooks.count.HP_chr_set_char_online_post ) { - void (*postHookFunc) (int *map_id, int *char_id, int *account_id); + void (*postHookFunc) (int map_id, int char_id, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_char_online_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_char_online_post[hIndex].func; - postHookFunc(&map_id, &char_id, &account_id); + postHookFunc(map_id, char_id, account_id); } } return; @@ -315,10 +316,10 @@ void HP_chr_set_char_offline(int char_id, int account_id) { HPMHooks.source.chr.set_char_offline(char_id, account_id); } if( HPMHooks.count.HP_chr_set_char_offline_post ) { - void (*postHookFunc) (int *char_id, int *account_id); + void (*postHookFunc) (int char_id, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_char_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_char_offline_post[hIndex].func; - postHookFunc(&char_id, &account_id); + postHookFunc(char_id, account_id); } } return; @@ -327,12 +328,12 @@ int HP_chr_db_setoffline(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_db_setoffline_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_db_setoffline_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chr_db_setoffline_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -346,11 +347,11 @@ int HP_chr_db_setoffline(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_chr_db_setoffline_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_db_setoffline_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chr_db_setoffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -360,12 +361,12 @@ int HP_chr_db_kickoffline(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_db_kickoffline_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_db_kickoffline_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chr_db_kickoffline_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -379,11 +380,11 @@ int HP_chr_db_kickoffline(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_chr_db_kickoffline_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_db_kickoffline_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chr_db_kickoffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -433,10 +434,10 @@ void HP_chr_set_all_offline(int id) { HPMHooks.source.chr.set_all_offline(id); } if( HPMHooks.count.HP_chr_set_all_offline_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_set_all_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_set_all_offline_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -469,8 +470,7 @@ void HP_chr_set_all_offline_sql(void) { } struct DBData HP_chr_create_charstatus(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_chr_create_charstatus_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -491,11 +491,11 @@ struct DBData HP_chr_create_charstatus(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_chr_create_charstatus_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_create_charstatus_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_chr_create_charstatus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -505,11 +505,11 @@ int HP_chr_mmo_char_tosql(int char_id, struct mmo_charstatus *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_char_tosql_pre ) { - int (*preHookFunc) (int *char_id, struct mmo_charstatus *p); + int (*preHookFunc) (int *char_id, struct mmo_charstatus **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_tosql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, p); + retVal___ = preHookFunc(&char_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -520,10 +520,10 @@ int HP_chr_mmo_char_tosql(int char_id, struct mmo_charstatus *p) { retVal___ = HPMHooks.source.chr.mmo_char_tosql(char_id, p); } if( HPMHooks.count.HP_chr_mmo_char_tosql_post ) { - int (*postHookFunc) (int retVal___, int *char_id, struct mmo_charstatus *p); + int (*postHookFunc) (int retVal___, int char_id, struct mmo_charstatus *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, p); + retVal___ = postHookFunc(retVal___, char_id, p); } } return retVal___; @@ -547,10 +547,10 @@ int HP_chr_memitemdata_to_sql(const struct item items[], int max, int id, int ta retVal___ = HPMHooks.source.chr.memitemdata_to_sql(items, max, id, tableswitch); } if( HPMHooks.count.HP_chr_memitemdata_to_sql_post ) { - int (*postHookFunc) (int retVal___, const struct item *items[], int *max, int *id, int *tableswitch); + int (*postHookFunc) (int retVal___, const struct item items[], int max, int id, int tableswitch); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_memitemdata_to_sql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_memitemdata_to_sql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &items, &max, &id, &tableswitch); + retVal___ = postHookFunc(retVal___, items, max, id, tableswitch); } } return retVal___; @@ -559,11 +559,11 @@ int HP_chr_mmo_gender(const struct char_session_data *sd, const struct mmo_chars int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_gender_pre ) { - int (*preHookFunc) (const struct char_session_data *sd, const struct mmo_charstatus *p, char *sex); + int (*preHookFunc) (const struct char_session_data **sd, const struct mmo_charstatus **p, char *sex); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_gender_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_gender_pre[hIndex].func; - retVal___ = preHookFunc(sd, p, &sex); + retVal___ = preHookFunc(&sd, &p, &sex); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -574,10 +574,10 @@ int HP_chr_mmo_gender(const struct char_session_data *sd, const struct mmo_chars retVal___ = HPMHooks.source.chr.mmo_gender(sd, p, sex); } if( HPMHooks.count.HP_chr_mmo_gender_post ) { - int (*postHookFunc) (int retVal___, const struct char_session_data *sd, const struct mmo_charstatus *p, char *sex); + int (*postHookFunc) (int retVal___, const struct char_session_data *sd, const struct mmo_charstatus *p, char sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_gender_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_gender_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, p, &sex); + retVal___ = postHookFunc(retVal___, sd, p, sex); } } return retVal___; @@ -586,11 +586,11 @@ int HP_chr_mmo_chars_fromsql(struct char_session_data *sd, uint8 *buf) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_chars_fromsql_pre ) { - int (*preHookFunc) (struct char_session_data *sd, uint8 *buf); + int (*preHookFunc) (struct char_session_data **sd, uint8 **buf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_chars_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_chars_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(sd, buf); + retVal___ = preHookFunc(&sd, &buf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -613,11 +613,11 @@ int HP_chr_mmo_char_fromsql(int char_id, struct mmo_charstatus *p, bool load_eve int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_char_fromsql_pre ) { - int (*preHookFunc) (int *char_id, struct mmo_charstatus *p, bool *load_everything); + int (*preHookFunc) (int *char_id, struct mmo_charstatus **p, bool *load_everything); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, p, &load_everything); + retVal___ = preHookFunc(&char_id, &p, &load_everything); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -628,10 +628,10 @@ int HP_chr_mmo_char_fromsql(int char_id, struct mmo_charstatus *p, bool load_eve retVal___ = HPMHooks.source.chr.mmo_char_fromsql(char_id, p, load_everything); } if( HPMHooks.count.HP_chr_mmo_char_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *char_id, struct mmo_charstatus *p, bool *load_everything); + int (*postHookFunc) (int retVal___, int char_id, struct mmo_charstatus *p, bool load_everything); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, p, &load_everything); + retVal___ = postHookFunc(retVal___, char_id, p, load_everything); } } return retVal___; @@ -667,11 +667,11 @@ bool HP_chr_char_slotchange(struct char_session_data *sd, int fd, unsigned short int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chr_char_slotchange_pre ) { - bool (*preHookFunc) (struct char_session_data *sd, int *fd, unsigned short *from, unsigned short *to); + bool (*preHookFunc) (struct char_session_data **sd, int *fd, unsigned short *from, unsigned short *to); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_slotchange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_char_slotchange_pre[hIndex].func; - retVal___ = preHookFunc(sd, &fd, &from, &to); + retVal___ = preHookFunc(&sd, &fd, &from, &to); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -682,10 +682,10 @@ bool HP_chr_char_slotchange(struct char_session_data *sd, int fd, unsigned short retVal___ = HPMHooks.source.chr.char_slotchange(sd, fd, from, to); } if( HPMHooks.count.HP_chr_char_slotchange_post ) { - bool (*postHookFunc) (bool retVal___, struct char_session_data *sd, int *fd, unsigned short *from, unsigned short *to); + bool (*postHookFunc) (bool retVal___, struct char_session_data *sd, int fd, unsigned short from, unsigned short to); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_slotchange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_char_slotchange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &fd, &from, &to); + retVal___ = postHookFunc(retVal___, sd, fd, from, to); } } return retVal___; @@ -694,11 +694,11 @@ int HP_chr_rename_char_sql(struct char_session_data *sd, int char_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_rename_char_sql_pre ) { - int (*preHookFunc) (struct char_session_data *sd, int *char_id); + int (*preHookFunc) (struct char_session_data **sd, int *char_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_rename_char_sql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_rename_char_sql_pre[hIndex].func; - retVal___ = preHookFunc(sd, &char_id); + retVal___ = preHookFunc(&sd, &char_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -709,10 +709,10 @@ int HP_chr_rename_char_sql(struct char_session_data *sd, int char_id) { retVal___ = HPMHooks.source.chr.rename_char_sql(sd, char_id); } if( HPMHooks.count.HP_chr_rename_char_sql_post ) { - int (*postHookFunc) (int retVal___, struct char_session_data *sd, int *char_id); + int (*postHookFunc) (int retVal___, struct char_session_data *sd, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_rename_char_sql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_rename_char_sql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &char_id); + retVal___ = postHookFunc(retVal___, sd, char_id); } } return retVal___; @@ -721,11 +721,11 @@ int HP_chr_check_char_name(char *name, char *esc_name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_check_char_name_pre ) { - int (*preHookFunc) (char *name, char *esc_name); + int (*preHookFunc) (char **name, char **esc_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_check_char_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_check_char_name_pre[hIndex].func; - retVal___ = preHookFunc(name, esc_name); + retVal___ = preHookFunc(&name, &esc_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -748,11 +748,11 @@ int HP_chr_make_new_char_sql(struct char_session_data *sd, const char *name_, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_make_new_char_sql_pre ) { - int (*preHookFunc) (struct char_session_data *sd, const char *name_, int *str, int *agi, int *vit, int *int_, int *dex, int *luk, int *slot, int *hair_color, int *hair_style); + int (*preHookFunc) (struct char_session_data **sd, const char **name_, int *str, int *agi, int *vit, int *int_, int *dex, int *luk, int *slot, int *hair_color, int *hair_style); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_make_new_char_sql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_make_new_char_sql_pre[hIndex].func; - retVal___ = preHookFunc(sd, name_, &str, &agi, &vit, &int_, &dex, &luk, &slot, &hair_color, &hair_style); + retVal___ = preHookFunc(&sd, &name_, &str, &agi, &vit, &int_, &dex, &luk, &slot, &hair_color, &hair_style); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -763,10 +763,10 @@ int HP_chr_make_new_char_sql(struct char_session_data *sd, const char *name_, in retVal___ = HPMHooks.source.chr.make_new_char_sql(sd, name_, str, agi, vit, int_, dex, luk, slot, hair_color, hair_style); } if( HPMHooks.count.HP_chr_make_new_char_sql_post ) { - int (*postHookFunc) (int retVal___, struct char_session_data *sd, const char *name_, int *str, int *agi, int *vit, int *int_, int *dex, int *luk, int *slot, int *hair_color, int *hair_style); + int (*postHookFunc) (int retVal___, struct char_session_data *sd, const char *name_, int str, int agi, int vit, int int_, int dex, int luk, int slot, int hair_color, int hair_style); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_make_new_char_sql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_make_new_char_sql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, name_, &str, &agi, &vit, &int_, &dex, &luk, &slot, &hair_color, &hair_style); + retVal___ = postHookFunc(retVal___, sd, name_, str, agi, vit, int_, dex, luk, slot, hair_color, hair_style); } } return retVal___; @@ -790,10 +790,10 @@ int HP_chr_divorce_char_sql(int partner_id1, int partner_id2) { retVal___ = HPMHooks.source.chr.divorce_char_sql(partner_id1, partner_id2); } if( HPMHooks.count.HP_chr_divorce_char_sql_post ) { - int (*postHookFunc) (int retVal___, int *partner_id1, int *partner_id2); + int (*postHookFunc) (int retVal___, int partner_id1, int partner_id2); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_divorce_char_sql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_divorce_char_sql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &partner_id1, &partner_id2); + retVal___ = postHookFunc(retVal___, partner_id1, partner_id2); } } return retVal___; @@ -829,11 +829,11 @@ int HP_chr_mmo_char_tobuf(uint8 *buffer, struct mmo_charstatus *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_char_tobuf_pre ) { - int (*preHookFunc) (uint8 *buffer, struct mmo_charstatus *p); + int (*preHookFunc) (uint8 **buffer, struct mmo_charstatus **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_tobuf_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_tobuf_pre[hIndex].func; - retVal___ = preHookFunc(buffer, p); + retVal___ = preHookFunc(&buffer, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -855,11 +855,11 @@ int HP_chr_mmo_char_tobuf(uint8 *buffer, struct mmo_charstatus *p) { void HP_chr_mmo_char_send099d(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_mmo_char_send099d_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send099d_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_send099d_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -870,10 +870,10 @@ void HP_chr_mmo_char_send099d(int fd, struct char_session_data *sd) { HPMHooks.source.chr.mmo_char_send099d(fd, sd); } if( HPMHooks.count.HP_chr_mmo_char_send099d_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send099d_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_send099d_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -881,11 +881,11 @@ void HP_chr_mmo_char_send099d(int fd, struct char_session_data *sd) { void HP_chr_mmo_char_send_ban_list(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_mmo_char_send_ban_list_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_ban_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_send_ban_list_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -896,10 +896,10 @@ void HP_chr_mmo_char_send_ban_list(int fd, struct char_session_data *sd) { HPMHooks.source.chr.mmo_char_send_ban_list(fd, sd); } if( HPMHooks.count.HP_chr_mmo_char_send_ban_list_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_ban_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_send_ban_list_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -907,11 +907,11 @@ void HP_chr_mmo_char_send_ban_list(int fd, struct char_session_data *sd) { void HP_chr_mmo_char_send_slots_info(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_mmo_char_send_slots_info_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_slots_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_send_slots_info_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -922,10 +922,10 @@ void HP_chr_mmo_char_send_slots_info(int fd, struct char_session_data *sd) { HPMHooks.source.chr.mmo_char_send_slots_info(fd, sd); } if( HPMHooks.count.HP_chr_mmo_char_send_slots_info_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_slots_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_send_slots_info_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -934,11 +934,11 @@ int HP_chr_mmo_char_send_characters(int fd, struct char_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_mmo_char_send_characters_pre ) { - int (*preHookFunc) (int *fd, struct char_session_data *sd); + int (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_characters_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_mmo_char_send_characters_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -949,10 +949,10 @@ int HP_chr_mmo_char_send_characters(int fd, struct char_session_data *sd) { retVal___ = HPMHooks.source.chr.mmo_char_send_characters(fd, sd); } if( HPMHooks.count.HP_chr_mmo_char_send_characters_post ) { - int (*postHookFunc) (int retVal___, int *fd, struct char_session_data *sd); + int (*postHookFunc) (int retVal___, int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mmo_char_send_characters_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mmo_char_send_characters_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -976,10 +976,10 @@ int HP_chr_char_married(int pl1, int pl2) { retVal___ = HPMHooks.source.chr.char_married(pl1, pl2); } if( HPMHooks.count.HP_chr_char_married_post ) { - int (*postHookFunc) (int retVal___, int *pl1, int *pl2); + int (*postHookFunc) (int retVal___, int pl1, int pl2); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_married_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_char_married_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pl1, &pl2); + retVal___ = postHookFunc(retVal___, pl1, pl2); } } return retVal___; @@ -1003,10 +1003,10 @@ int HP_chr_char_child(int parent_id, int child_id) { retVal___ = HPMHooks.source.chr.char_child(parent_id, child_id); } if( HPMHooks.count.HP_chr_char_child_post ) { - int (*postHookFunc) (int retVal___, int *parent_id, int *child_id); + int (*postHookFunc) (int retVal___, int parent_id, int child_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_child_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_char_child_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &parent_id, &child_id); + retVal___ = postHookFunc(retVal___, parent_id, child_id); } } return retVal___; @@ -1030,10 +1030,10 @@ int HP_chr_char_family(int cid1, int cid2, int cid3) { retVal___ = HPMHooks.source.chr.char_family(cid1, cid2, cid3); } if( HPMHooks.count.HP_chr_char_family_post ) { - int (*postHookFunc) (int retVal___, int *cid1, int *cid2, int *cid3); + int (*postHookFunc) (int retVal___, int cid1, int cid2, int cid3); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_family_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_char_family_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &cid1, &cid2, &cid3); + retVal___ = postHookFunc(retVal___, cid1, cid2, cid3); } } return retVal___; @@ -1056,10 +1056,10 @@ void HP_chr_disconnect_player(int account_id) { HPMHooks.source.chr.disconnect_player(account_id); } if( HPMHooks.count.HP_chr_disconnect_player_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_disconnect_player_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_disconnect_player_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -1082,10 +1082,10 @@ void HP_chr_authfail_fd(int fd, int type) { HPMHooks.source.chr.authfail_fd(fd, type); } if( HPMHooks.count.HP_chr_authfail_fd_post ) { - void (*postHookFunc) (int *fd, int *type); + void (*postHookFunc) (int fd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_authfail_fd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_authfail_fd_post[hIndex].func; - postHookFunc(&fd, &type); + postHookFunc(fd, type); } } return; @@ -1108,10 +1108,10 @@ void HP_chr_request_account_data(int account_id) { HPMHooks.source.chr.request_account_data(account_id); } if( HPMHooks.count.HP_chr_request_account_data_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_request_account_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_request_account_data_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -1119,11 +1119,11 @@ void HP_chr_request_account_data(int account_id) { void HP_chr_auth_ok(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_auth_ok_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_auth_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_auth_ok_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1134,10 +1134,10 @@ void HP_chr_auth_ok(int fd, struct char_session_data *sd) { HPMHooks.source.chr.auth_ok(fd, sd); } if( HPMHooks.count.HP_chr_auth_ok_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_auth_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_auth_ok_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -1160,10 +1160,10 @@ void HP_chr_ping_login_server(int fd) { HPMHooks.source.chr.ping_login_server(fd); } if( HPMHooks.count.HP_chr_ping_login_server_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_ping_login_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_ping_login_server_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1187,10 +1187,10 @@ int HP_chr_parse_fromlogin_connection_state(int fd) { retVal___ = HPMHooks.source.chr.parse_fromlogin_connection_state(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_connection_state_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_connection_state_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_connection_state_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1213,10 +1213,10 @@ void HP_chr_auth_error(int fd, unsigned char flag) { HPMHooks.source.chr.auth_error(fd, flag); } if( HPMHooks.count.HP_chr_auth_error_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_auth_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_auth_error_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -1239,10 +1239,10 @@ void HP_chr_parse_fromlogin_auth_state(int fd) { HPMHooks.source.chr.parse_fromlogin_auth_state(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_auth_state_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_auth_state_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_auth_state_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1265,10 +1265,10 @@ void HP_chr_parse_fromlogin_account_data(int fd) { HPMHooks.source.chr.parse_fromlogin_account_data(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_account_data_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_account_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_account_data_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1291,10 +1291,10 @@ void HP_chr_parse_fromlogin_login_pong(int fd) { HPMHooks.source.chr.parse_fromlogin_login_pong(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_login_pong_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_login_pong_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_login_pong_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1317,10 +1317,10 @@ void HP_chr_changesex(int account_id, int sex) { HPMHooks.source.chr.changesex(account_id, sex); } if( HPMHooks.count.HP_chr_changesex_post ) { - void (*postHookFunc) (int *account_id, int *sex); + void (*postHookFunc) (int account_id, int sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_changesex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_changesex_post[hIndex].func; - postHookFunc(&account_id, &sex); + postHookFunc(account_id, sex); } } return; @@ -1344,10 +1344,10 @@ int HP_chr_parse_fromlogin_changesex_reply(int fd) { retVal___ = HPMHooks.source.chr.parse_fromlogin_changesex_reply(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_changesex_reply_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_changesex_reply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_changesex_reply_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1370,10 +1370,10 @@ void HP_chr_parse_fromlogin_account_reg2(int fd) { HPMHooks.source.chr.parse_fromlogin_account_reg2(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_account_reg2_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_account_reg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_account_reg2_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1396,10 +1396,10 @@ void HP_chr_parse_fromlogin_ban(int fd) { HPMHooks.source.chr.parse_fromlogin_ban(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_ban_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_ban_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1422,10 +1422,10 @@ void HP_chr_parse_fromlogin_kick(int fd) { HPMHooks.source.chr.parse_fromlogin_kick(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_kick_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_kick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_kick_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1448,10 +1448,10 @@ void HP_chr_update_ip(int fd) { HPMHooks.source.chr.update_ip(fd); } if( HPMHooks.count.HP_chr_update_ip_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_update_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_update_ip_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1474,10 +1474,10 @@ void HP_chr_parse_fromlogin_update_ip(int fd) { HPMHooks.source.chr.parse_fromlogin_update_ip(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_update_ip_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_update_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_update_ip_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1500,10 +1500,10 @@ void HP_chr_parse_fromlogin_accinfo2_failed(int fd) { HPMHooks.source.chr.parse_fromlogin_accinfo2_failed(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_accinfo2_failed_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_accinfo2_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_accinfo2_failed_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1526,10 +1526,10 @@ void HP_chr_parse_fromlogin_accinfo2_ok(int fd) { HPMHooks.source.chr.parse_fromlogin_accinfo2_ok(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_accinfo2_ok_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_accinfo2_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_accinfo2_ok_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1553,10 +1553,10 @@ int HP_chr_parse_fromlogin(int fd) { retVal___ = HPMHooks.source.chr.parse_fromlogin(fd); } if( HPMHooks.count.HP_chr_parse_fromlogin_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_fromlogin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_fromlogin_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1580,10 +1580,10 @@ int HP_chr_request_accreg2(int account_id, int char_id) { retVal___ = HPMHooks.source.chr.request_accreg2(account_id, char_id); } if( HPMHooks.count.HP_chr_request_accreg2_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_request_accreg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_request_accreg2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, account_id, char_id); } } return retVal___; @@ -1606,10 +1606,10 @@ void HP_chr_global_accreg_to_login_start(int account_id, int char_id) { HPMHooks.source.chr.global_accreg_to_login_start(account_id, char_id); } if( HPMHooks.count.HP_chr_global_accreg_to_login_start_post ) { - void (*postHookFunc) (int *account_id, int *char_id); + void (*postHookFunc) (int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_global_accreg_to_login_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_global_accreg_to_login_start_post[hIndex].func; - postHookFunc(&account_id, &char_id); + postHookFunc(account_id, char_id); } } return; @@ -1643,11 +1643,11 @@ void HP_chr_global_accreg_to_login_send(void) { void HP_chr_global_accreg_to_login_add(const char *key, unsigned int index, intptr_t val, bool is_string) { int hIndex = 0; if( HPMHooks.count.HP_chr_global_accreg_to_login_add_pre ) { - void (*preHookFunc) (const char *key, unsigned int *index, intptr_t *val, bool *is_string); + void (*preHookFunc) (const char **key, unsigned int *index, intptr_t *val, bool *is_string); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_global_accreg_to_login_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_global_accreg_to_login_add_pre[hIndex].func; - preHookFunc(key, &index, &val, &is_string); + preHookFunc(&key, &index, &val, &is_string); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1658,10 +1658,10 @@ void HP_chr_global_accreg_to_login_add(const char *key, unsigned int index, intp HPMHooks.source.chr.global_accreg_to_login_add(key, index, val, is_string); } if( HPMHooks.count.HP_chr_global_accreg_to_login_add_post ) { - void (*postHookFunc) (const char *key, unsigned int *index, intptr_t *val, bool *is_string); + void (*postHookFunc) (const char *key, unsigned int index, intptr_t val, bool is_string); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_global_accreg_to_login_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_global_accreg_to_login_add_post[hIndex].func; - postHookFunc(key, &index, &val, &is_string); + postHookFunc(key, index, val, is_string); } } return; @@ -1711,10 +1711,10 @@ int HP_chr_send_fame_list(int fd) { retVal___ = HPMHooks.source.chr.send_fame_list(fd); } if( HPMHooks.count.HP_chr_send_fame_list_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_fame_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_fame_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1737,10 +1737,10 @@ void HP_chr_update_fame_list(int type, int index, int fame) { HPMHooks.source.chr.update_fame_list(type, index, fame); } if( HPMHooks.count.HP_chr_update_fame_list_post ) { - void (*postHookFunc) (int *type, int *index, int *fame); + void (*postHookFunc) (int type, int index, int fame); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_update_fame_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_update_fame_list_post[hIndex].func; - postHookFunc(&type, &index, &fame); + postHookFunc(type, index, fame); } } return; @@ -1749,11 +1749,11 @@ int HP_chr_loadName(int char_id, char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_loadName_pre ) { - int (*preHookFunc) (int *char_id, char *name); + int (*preHookFunc) (int *char_id, char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_loadName_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_loadName_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, name); + retVal___ = preHookFunc(&char_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1764,10 +1764,10 @@ int HP_chr_loadName(int char_id, char *name) { retVal___ = HPMHooks.source.chr.loadName(char_id, name); } if( HPMHooks.count.HP_chr_loadName_post ) { - int (*postHookFunc) (int retVal___, int *char_id, char *name); + int (*postHookFunc) (int retVal___, int char_id, char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_loadName_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_loadName_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, name); + retVal___ = postHookFunc(retVal___, char_id, name); } } return retVal___; @@ -1790,10 +1790,10 @@ void HP_chr_parse_frommap_datasync(int fd) { HPMHooks.source.chr.parse_frommap_datasync(fd); } if( HPMHooks.count.HP_chr_parse_frommap_datasync_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_datasync_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_datasync_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1816,10 +1816,10 @@ void HP_chr_parse_frommap_skillid2idx(int fd) { HPMHooks.source.chr.parse_frommap_skillid2idx(fd); } if( HPMHooks.count.HP_chr_parse_frommap_skillid2idx_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_skillid2idx_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_skillid2idx_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1842,10 +1842,10 @@ void HP_chr_map_received_ok(int fd) { HPMHooks.source.chr.map_received_ok(fd); } if( HPMHooks.count.HP_chr_map_received_ok_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_map_received_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_map_received_ok_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1868,10 +1868,10 @@ void HP_chr_send_maps(int fd, int id, int j) { HPMHooks.source.chr.send_maps(fd, id, j); } if( HPMHooks.count.HP_chr_send_maps_post ) { - void (*postHookFunc) (int *fd, int *id, int *j); + void (*postHookFunc) (int fd, int id, int j); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_maps_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_maps_post[hIndex].func; - postHookFunc(&fd, &id, &j); + postHookFunc(fd, id, j); } } return; @@ -1894,10 +1894,10 @@ void HP_chr_parse_frommap_map_names(int fd, int id) { HPMHooks.source.chr.parse_frommap_map_names(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_map_names_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_map_names_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_map_names_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -1920,10 +1920,10 @@ void HP_chr_send_scdata(int fd, int aid, int cid) { HPMHooks.source.chr.send_scdata(fd, aid, cid); } if( HPMHooks.count.HP_chr_send_scdata_post ) { - void (*postHookFunc) (int *fd, int *aid, int *cid); + void (*postHookFunc) (int fd, int aid, int cid); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_scdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_scdata_post[hIndex].func; - postHookFunc(&fd, &aid, &cid); + postHookFunc(fd, aid, cid); } } return; @@ -1946,10 +1946,10 @@ void HP_chr_parse_frommap_request_scdata(int fd) { HPMHooks.source.chr.parse_frommap_request_scdata(fd); } if( HPMHooks.count.HP_chr_parse_frommap_request_scdata_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_request_scdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_request_scdata_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -1972,10 +1972,10 @@ void HP_chr_parse_frommap_set_users_count(int fd, int id) { HPMHooks.source.chr.parse_frommap_set_users_count(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_set_users_count_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_set_users_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_set_users_count_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -1998,10 +1998,10 @@ void HP_chr_parse_frommap_set_users(int fd, int id) { HPMHooks.source.chr.parse_frommap_set_users(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_set_users_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_set_users_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_set_users_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2024,10 +2024,10 @@ void HP_chr_save_character_ack(int fd, int aid, int cid) { HPMHooks.source.chr.save_character_ack(fd, aid, cid); } if( HPMHooks.count.HP_chr_save_character_ack_post ) { - void (*postHookFunc) (int *fd, int *aid, int *cid); + void (*postHookFunc) (int fd, int aid, int cid); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_save_character_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_save_character_ack_post[hIndex].func; - postHookFunc(&fd, &aid, &cid); + postHookFunc(fd, aid, cid); } } return; @@ -2050,10 +2050,10 @@ void HP_chr_parse_frommap_save_character(int fd, int id) { HPMHooks.source.chr.parse_frommap_save_character(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_save_character_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_save_character_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_save_character_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2076,10 +2076,10 @@ void HP_chr_select_ack(int fd, int account_id, uint8 flag) { HPMHooks.source.chr.select_ack(fd, account_id, flag); } if( HPMHooks.count.HP_chr_select_ack_post ) { - void (*postHookFunc) (int *fd, int *account_id, uint8 *flag); + void (*postHookFunc) (int fd, int account_id, uint8 flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_select_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_select_ack_post[hIndex].func; - postHookFunc(&fd, &account_id, &flag); + postHookFunc(fd, account_id, flag); } } return; @@ -2102,10 +2102,10 @@ void HP_chr_parse_frommap_char_select_req(int fd) { HPMHooks.source.chr.parse_frommap_char_select_req(fd); } if( HPMHooks.count.HP_chr_parse_frommap_char_select_req_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_char_select_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_char_select_req_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2113,11 +2113,11 @@ void HP_chr_parse_frommap_char_select_req(int fd) { void HP_chr_change_map_server_ack(int fd, const uint8 *data, bool ok) { int hIndex = 0; if( HPMHooks.count.HP_chr_change_map_server_ack_pre ) { - void (*preHookFunc) (int *fd, const uint8 *data, bool *ok); + void (*preHookFunc) (int *fd, const uint8 **data, bool *ok); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_change_map_server_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_change_map_server_ack_pre[hIndex].func; - preHookFunc(&fd, data, &ok); + preHookFunc(&fd, &data, &ok); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2128,10 +2128,10 @@ void HP_chr_change_map_server_ack(int fd, const uint8 *data, bool ok) { HPMHooks.source.chr.change_map_server_ack(fd, data, ok); } if( HPMHooks.count.HP_chr_change_map_server_ack_post ) { - void (*postHookFunc) (int *fd, const uint8 *data, bool *ok); + void (*postHookFunc) (int fd, const uint8 *data, bool ok); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_change_map_server_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_change_map_server_ack_post[hIndex].func; - postHookFunc(&fd, data, &ok); + postHookFunc(fd, data, ok); } } return; @@ -2154,10 +2154,10 @@ void HP_chr_parse_frommap_change_map_server(int fd) { HPMHooks.source.chr.parse_frommap_change_map_server(fd); } if( HPMHooks.count.HP_chr_parse_frommap_change_map_server_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_change_map_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_change_map_server_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2180,10 +2180,10 @@ void HP_chr_parse_frommap_remove_friend(int fd) { HPMHooks.source.chr.parse_frommap_remove_friend(fd); } if( HPMHooks.count.HP_chr_parse_frommap_remove_friend_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_remove_friend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_remove_friend_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2206,10 +2206,10 @@ void HP_chr_char_name_ack(int fd, int char_id) { HPMHooks.source.chr.char_name_ack(fd, char_id); } if( HPMHooks.count.HP_chr_char_name_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id); + void (*postHookFunc) (int fd, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_char_name_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_char_name_ack_post[hIndex].func; - postHookFunc(&fd, &char_id); + postHookFunc(fd, char_id); } } return; @@ -2232,10 +2232,10 @@ void HP_chr_parse_frommap_char_name_request(int fd) { HPMHooks.source.chr.parse_frommap_char_name_request(fd); } if( HPMHooks.count.HP_chr_parse_frommap_char_name_request_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_char_name_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_char_name_request_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2258,10 +2258,10 @@ void HP_chr_parse_frommap_change_email(int fd) { HPMHooks.source.chr.parse_frommap_change_email(fd); } if( HPMHooks.count.HP_chr_parse_frommap_change_email_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_change_email_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_change_email_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2269,11 +2269,11 @@ void HP_chr_parse_frommap_change_email(int fd) { void HP_chr_ban(int account_id, int char_id, time_t *unban_time, short year, short month, short day, short hour, short minute, short second) { int hIndex = 0; if( HPMHooks.count.HP_chr_ban_pre ) { - void (*preHookFunc) (int *account_id, int *char_id, time_t *unban_time, short *year, short *month, short *day, short *hour, short *minute, short *second); + void (*preHookFunc) (int *account_id, int *char_id, time_t **unban_time, short *year, short *month, short *day, short *hour, short *minute, short *second); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_ban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_ban_pre[hIndex].func; - preHookFunc(&account_id, &char_id, unban_time, &year, &month, &day, &hour, &minute, &second); + preHookFunc(&account_id, &char_id, &unban_time, &year, &month, &day, &hour, &minute, &second); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2284,10 +2284,10 @@ void HP_chr_ban(int account_id, int char_id, time_t *unban_time, short year, sho HPMHooks.source.chr.ban(account_id, char_id, unban_time, year, month, day, hour, minute, second); } if( HPMHooks.count.HP_chr_ban_post ) { - void (*postHookFunc) (int *account_id, int *char_id, time_t *unban_time, short *year, short *month, short *day, short *hour, short *minute, short *second); + void (*postHookFunc) (int account_id, int char_id, time_t *unban_time, short year, short month, short day, short hour, short minute, short second); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_ban_post[hIndex].func; - postHookFunc(&account_id, &char_id, unban_time, &year, &month, &day, &hour, &minute, &second); + postHookFunc(account_id, char_id, unban_time, year, month, day, hour, minute, second); } } return; @@ -2295,11 +2295,11 @@ void HP_chr_ban(int account_id, int char_id, time_t *unban_time, short year, sho void HP_chr_unban(int char_id, int *result) { int hIndex = 0; if( HPMHooks.count.HP_chr_unban_pre ) { - void (*preHookFunc) (int *char_id, int *result); + void (*preHookFunc) (int *char_id, int **result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_unban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_unban_pre[hIndex].func; - preHookFunc(&char_id, result); + preHookFunc(&char_id, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2310,10 +2310,10 @@ void HP_chr_unban(int char_id, int *result) { HPMHooks.source.chr.unban(char_id, result); } if( HPMHooks.count.HP_chr_unban_post ) { - void (*postHookFunc) (int *char_id, int *result); + void (*postHookFunc) (int char_id, int *result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_unban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_unban_post[hIndex].func; - postHookFunc(&char_id, result); + postHookFunc(char_id, result); } } return; @@ -2321,11 +2321,11 @@ void HP_chr_unban(int char_id, int *result) { void HP_chr_ask_name_ack(int fd, int acc, const char *name, int type, int result) { int hIndex = 0; if( HPMHooks.count.HP_chr_ask_name_ack_pre ) { - void (*preHookFunc) (int *fd, int *acc, const char *name, int *type, int *result); + void (*preHookFunc) (int *fd, int *acc, const char **name, int *type, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_ask_name_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_ask_name_ack_pre[hIndex].func; - preHookFunc(&fd, &acc, name, &type, &result); + preHookFunc(&fd, &acc, &name, &type, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2336,10 +2336,10 @@ void HP_chr_ask_name_ack(int fd, int acc, const char *name, int type, int result HPMHooks.source.chr.ask_name_ack(fd, acc, name, type, result); } if( HPMHooks.count.HP_chr_ask_name_ack_post ) { - void (*postHookFunc) (int *fd, int *acc, const char *name, int *type, int *result); + void (*postHookFunc) (int fd, int acc, const char *name, int type, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_ask_name_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_ask_name_ack_post[hIndex].func; - postHookFunc(&fd, &acc, name, &type, &result); + postHookFunc(fd, acc, name, type, result); } } return; @@ -2363,10 +2363,10 @@ int HP_chr_changecharsex(int char_id, int sex) { retVal___ = HPMHooks.source.chr.changecharsex(char_id, sex); } if( HPMHooks.count.HP_chr_changecharsex_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *sex); + int (*postHookFunc) (int retVal___, int char_id, int sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_changecharsex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_changecharsex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &sex); + retVal___ = postHookFunc(retVal___, char_id, sex); } } return retVal___; @@ -2389,10 +2389,10 @@ void HP_chr_parse_frommap_change_account(int fd) { HPMHooks.source.chr.parse_frommap_change_account(fd); } if( HPMHooks.count.HP_chr_parse_frommap_change_account_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_change_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_change_account_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2415,10 +2415,10 @@ void HP_chr_parse_frommap_fame_list(int fd) { HPMHooks.source.chr.parse_frommap_fame_list(fd); } if( HPMHooks.count.HP_chr_parse_frommap_fame_list_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_fame_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_fame_list_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2441,10 +2441,10 @@ void HP_chr_parse_frommap_divorce_char(int fd) { HPMHooks.source.chr.parse_frommap_divorce_char(fd); } if( HPMHooks.count.HP_chr_parse_frommap_divorce_char_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_divorce_char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_divorce_char_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2467,10 +2467,10 @@ void HP_chr_parse_frommap_ragsrvinfo(int fd) { HPMHooks.source.chr.parse_frommap_ragsrvinfo(fd); } if( HPMHooks.count.HP_chr_parse_frommap_ragsrvinfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_ragsrvinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_ragsrvinfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2493,10 +2493,10 @@ void HP_chr_parse_frommap_set_char_offline(int fd) { HPMHooks.source.chr.parse_frommap_set_char_offline(fd); } if( HPMHooks.count.HP_chr_parse_frommap_set_char_offline_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_set_char_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_set_char_offline_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2519,10 +2519,10 @@ void HP_chr_parse_frommap_set_all_offline(int fd, int id) { HPMHooks.source.chr.parse_frommap_set_all_offline(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_set_all_offline_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_set_all_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_set_all_offline_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2545,10 +2545,10 @@ void HP_chr_parse_frommap_set_char_online(int fd, int id) { HPMHooks.source.chr.parse_frommap_set_char_online(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_set_char_online_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_set_char_online_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_set_char_online_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2571,10 +2571,10 @@ void HP_chr_parse_frommap_build_fame_list(int fd) { HPMHooks.source.chr.parse_frommap_build_fame_list(fd); } if( HPMHooks.count.HP_chr_parse_frommap_build_fame_list_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_build_fame_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_build_fame_list_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2597,10 +2597,10 @@ void HP_chr_parse_frommap_save_status_change_data(int fd) { HPMHooks.source.chr.parse_frommap_save_status_change_data(fd); } if( HPMHooks.count.HP_chr_parse_frommap_save_status_change_data_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_save_status_change_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_save_status_change_data_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2623,10 +2623,10 @@ void HP_chr_send_pong(int fd) { HPMHooks.source.chr.send_pong(fd); } if( HPMHooks.count.HP_chr_send_pong_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_pong_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_pong_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2649,10 +2649,10 @@ void HP_chr_parse_frommap_ping(int fd) { HPMHooks.source.chr.parse_frommap_ping(fd); } if( HPMHooks.count.HP_chr_parse_frommap_ping_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_ping_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_ping_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2660,11 +2660,11 @@ void HP_chr_parse_frommap_ping(int fd) { void HP_chr_map_auth_ok(int fd, int account_id, struct char_auth_node *node, struct mmo_charstatus *cd) { int hIndex = 0; if( HPMHooks.count.HP_chr_map_auth_ok_pre ) { - void (*preHookFunc) (int *fd, int *account_id, struct char_auth_node *node, struct mmo_charstatus *cd); + void (*preHookFunc) (int *fd, int *account_id, struct char_auth_node **node, struct mmo_charstatus **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_map_auth_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_map_auth_ok_pre[hIndex].func; - preHookFunc(&fd, &account_id, node, cd); + preHookFunc(&fd, &account_id, &node, &cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2675,10 +2675,10 @@ void HP_chr_map_auth_ok(int fd, int account_id, struct char_auth_node *node, str HPMHooks.source.chr.map_auth_ok(fd, account_id, node, cd); } if( HPMHooks.count.HP_chr_map_auth_ok_post ) { - void (*postHookFunc) (int *fd, int *account_id, struct char_auth_node *node, struct mmo_charstatus *cd); + void (*postHookFunc) (int fd, int account_id, struct char_auth_node *node, struct mmo_charstatus *cd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_map_auth_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_map_auth_ok_post[hIndex].func; - postHookFunc(&fd, &account_id, node, cd); + postHookFunc(fd, account_id, node, cd); } } return; @@ -2701,10 +2701,10 @@ void HP_chr_map_auth_failed(int fd, int account_id, int char_id, int login_id1, HPMHooks.source.chr.map_auth_failed(fd, account_id, char_id, login_id1, sex, ip); } if( HPMHooks.count.HP_chr_map_auth_failed_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *char_id, int *login_id1, char *sex, uint32 *ip); + void (*postHookFunc) (int fd, int account_id, int char_id, int login_id1, char sex, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_map_auth_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_map_auth_failed_post[hIndex].func; - postHookFunc(&fd, &account_id, &char_id, &login_id1, &sex, &ip); + postHookFunc(fd, account_id, char_id, login_id1, sex, ip); } } return; @@ -2727,10 +2727,10 @@ void HP_chr_parse_frommap_auth_request(int fd, int id) { HPMHooks.source.chr.parse_frommap_auth_request(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_auth_request_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_auth_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_auth_request_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2753,10 +2753,10 @@ void HP_chr_parse_frommap_update_ip(int fd, int id) { HPMHooks.source.chr.parse_frommap_update_ip(fd, id); } if( HPMHooks.count.HP_chr_parse_frommap_update_ip_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_update_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_update_ip_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -2779,10 +2779,10 @@ void HP_chr_parse_frommap_request_stats_report(int fd) { HPMHooks.source.chr.parse_frommap_request_stats_report(fd); } if( HPMHooks.count.HP_chr_parse_frommap_request_stats_report_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_request_stats_report_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_request_stats_report_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2805,10 +2805,10 @@ void HP_chr_parse_frommap_scdata_update(int fd) { HPMHooks.source.chr.parse_frommap_scdata_update(fd); } if( HPMHooks.count.HP_chr_parse_frommap_scdata_update_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_scdata_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_scdata_update_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2831,10 +2831,10 @@ void HP_chr_parse_frommap_scdata_delete(int fd) { HPMHooks.source.chr.parse_frommap_scdata_delete(fd); } if( HPMHooks.count.HP_chr_parse_frommap_scdata_delete_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_scdata_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_scdata_delete_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -2858,10 +2858,10 @@ int HP_chr_parse_frommap(int fd) { retVal___ = HPMHooks.source.chr.parse_frommap(fd); } if( HPMHooks.count.HP_chr_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -2885,10 +2885,10 @@ int HP_chr_search_mapserver(unsigned short map, uint32 ip, uint16 port) { retVal___ = HPMHooks.source.chr.search_mapserver(map, ip, port); } if( HPMHooks.count.HP_chr_search_mapserver_post ) { - int (*postHookFunc) (int retVal___, unsigned short *map, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, unsigned short map, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_search_mapserver_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_search_mapserver_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map, &ip, &port); + retVal___ = postHookFunc(retVal___, map, ip, port); } } return retVal___; @@ -2912,10 +2912,10 @@ int HP_chr_mapif_init(int fd) { retVal___ = HPMHooks.source.chr.mapif_init(fd); } if( HPMHooks.count.HP_chr_mapif_init_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_mapif_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_mapif_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -2939,10 +2939,10 @@ uint32 HP_chr_lan_subnet_check(uint32 ip) { retVal___ = HPMHooks.source.chr.lan_subnet_check(ip); } if( HPMHooks.count.HP_chr_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip); + uint32 (*postHookFunc) (uint32 retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_lan_subnet_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_lan_subnet_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -2965,10 +2965,10 @@ void HP_chr_delete2_ack(int fd, int char_id, uint32 result, time_t delete_date) HPMHooks.source.chr.delete2_ack(fd, char_id, result, delete_date); } if( HPMHooks.count.HP_chr_delete2_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id, uint32 *result, time_t *delete_date); + void (*postHookFunc) (int fd, int char_id, uint32 result, time_t delete_date); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_ack_post[hIndex].func; - postHookFunc(&fd, &char_id, &result, &delete_date); + postHookFunc(fd, char_id, result, delete_date); } } return; @@ -2991,10 +2991,10 @@ void HP_chr_delete2_accept_actual_ack(int fd, int char_id, uint32 result) { HPMHooks.source.chr.delete2_accept_actual_ack(fd, char_id, result); } if( HPMHooks.count.HP_chr_delete2_accept_actual_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id, uint32 *result); + void (*postHookFunc) (int fd, int char_id, uint32 result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_accept_actual_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_accept_actual_ack_post[hIndex].func; - postHookFunc(&fd, &char_id, &result); + postHookFunc(fd, char_id, result); } } return; @@ -3017,10 +3017,10 @@ void HP_chr_delete2_accept_ack(int fd, int char_id, uint32 result) { HPMHooks.source.chr.delete2_accept_ack(fd, char_id, result); } if( HPMHooks.count.HP_chr_delete2_accept_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id, uint32 *result); + void (*postHookFunc) (int fd, int char_id, uint32 result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_accept_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_accept_ack_post[hIndex].func; - postHookFunc(&fd, &char_id, &result); + postHookFunc(fd, char_id, result); } } return; @@ -3043,10 +3043,10 @@ void HP_chr_delete2_cancel_ack(int fd, int char_id, uint32 result) { HPMHooks.source.chr.delete2_cancel_ack(fd, char_id, result); } if( HPMHooks.count.HP_chr_delete2_cancel_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id, uint32 *result); + void (*postHookFunc) (int fd, int char_id, uint32 result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_cancel_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_cancel_ack_post[hIndex].func; - postHookFunc(&fd, &char_id, &result); + postHookFunc(fd, char_id, result); } } return; @@ -3054,11 +3054,11 @@ void HP_chr_delete2_cancel_ack(int fd, int char_id, uint32 result) { void HP_chr_delete2_req(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_delete2_req_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_req_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_delete2_req_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3069,10 +3069,10 @@ void HP_chr_delete2_req(int fd, struct char_session_data *sd) { HPMHooks.source.chr.delete2_req(fd, sd); } if( HPMHooks.count.HP_chr_delete2_req_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_req_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3080,11 +3080,11 @@ void HP_chr_delete2_req(int fd, struct char_session_data *sd) { void HP_chr_delete2_accept(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_delete2_accept_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_accept_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_delete2_accept_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3095,10 +3095,10 @@ void HP_chr_delete2_accept(int fd, struct char_session_data *sd) { HPMHooks.source.chr.delete2_accept(fd, sd); } if( HPMHooks.count.HP_chr_delete2_accept_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_accept_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_accept_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3106,11 +3106,11 @@ void HP_chr_delete2_accept(int fd, struct char_session_data *sd) { void HP_chr_delete2_cancel(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_delete2_cancel_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_cancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_delete2_cancel_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3121,10 +3121,10 @@ void HP_chr_delete2_cancel(int fd, struct char_session_data *sd) { HPMHooks.source.chr.delete2_cancel(fd, sd); } if( HPMHooks.count.HP_chr_delete2_cancel_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete2_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete2_cancel_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3147,10 +3147,10 @@ void HP_chr_send_account_id(int fd, int account_id) { HPMHooks.source.chr.send_account_id(fd, account_id); } if( HPMHooks.count.HP_chr_send_account_id_post ) { - void (*postHookFunc) (int *fd, int *account_id); + void (*postHookFunc) (int fd, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_account_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_account_id_post[hIndex].func; - postHookFunc(&fd, &account_id); + postHookFunc(fd, account_id); } } return; @@ -3158,11 +3158,11 @@ void HP_chr_send_account_id(int fd, int account_id) { void HP_chr_parse_char_connect(int fd, struct char_session_data *sd, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_connect_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*preHookFunc) (int *fd, struct char_session_data **sd, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_connect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_connect_pre[hIndex].func; - preHookFunc(&fd, sd, &ipl); + preHookFunc(&fd, &sd, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3173,10 +3173,10 @@ void HP_chr_parse_char_connect(int fd, struct char_session_data *sd, uint32 ipl) HPMHooks.source.chr.parse_char_connect(fd, sd, ipl); } if( HPMHooks.count.HP_chr_parse_char_connect_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*postHookFunc) (int fd, struct char_session_data *sd, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_connect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_connect_post[hIndex].func; - postHookFunc(&fd, sd, &ipl); + postHookFunc(fd, sd, ipl); } } return; @@ -3184,11 +3184,11 @@ void HP_chr_parse_char_connect(int fd, struct char_session_data *sd, uint32 ipl) void HP_chr_send_map_info(int fd, int i, uint32 subnet_map_ip, struct mmo_charstatus *cd) { int hIndex = 0; if( HPMHooks.count.HP_chr_send_map_info_pre ) { - void (*preHookFunc) (int *fd, int *i, uint32 *subnet_map_ip, struct mmo_charstatus *cd); + void (*preHookFunc) (int *fd, int *i, uint32 *subnet_map_ip, struct mmo_charstatus **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_map_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_send_map_info_pre[hIndex].func; - preHookFunc(&fd, &i, &subnet_map_ip, cd); + preHookFunc(&fd, &i, &subnet_map_ip, &cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3199,10 +3199,10 @@ void HP_chr_send_map_info(int fd, int i, uint32 subnet_map_ip, struct mmo_charst HPMHooks.source.chr.send_map_info(fd, i, subnet_map_ip, cd); } if( HPMHooks.count.HP_chr_send_map_info_post ) { - void (*postHookFunc) (int *fd, int *i, uint32 *subnet_map_ip, struct mmo_charstatus *cd); + void (*postHookFunc) (int fd, int i, uint32 subnet_map_ip, struct mmo_charstatus *cd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_map_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_map_info_post[hIndex].func; - postHookFunc(&fd, &i, &subnet_map_ip, cd); + postHookFunc(fd, i, subnet_map_ip, cd); } } return; @@ -3225,10 +3225,10 @@ void HP_chr_send_wait_char_server(int fd) { HPMHooks.source.chr.send_wait_char_server(fd); } if( HPMHooks.count.HP_chr_send_wait_char_server_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_wait_char_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_wait_char_server_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3237,11 +3237,11 @@ int HP_chr_search_default_maps_mapserver(struct mmo_charstatus *cd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_search_default_maps_mapserver_pre ) { - int (*preHookFunc) (struct mmo_charstatus *cd); + int (*preHookFunc) (struct mmo_charstatus **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_search_default_maps_mapserver_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_search_default_maps_mapserver_pre[hIndex].func; - retVal___ = preHookFunc(cd); + retVal___ = preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3263,11 +3263,11 @@ int HP_chr_search_default_maps_mapserver(struct mmo_charstatus *cd) { void HP_chr_parse_char_select(int fd, struct char_session_data *sd, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_select_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*preHookFunc) (int *fd, struct char_session_data **sd, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_select_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_select_pre[hIndex].func; - preHookFunc(&fd, sd, &ipl); + preHookFunc(&fd, &sd, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3278,10 +3278,10 @@ void HP_chr_parse_char_select(int fd, struct char_session_data *sd, uint32 ipl) HPMHooks.source.chr.parse_char_select(fd, sd, ipl); } if( HPMHooks.count.HP_chr_parse_char_select_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*postHookFunc) (int fd, struct char_session_data *sd, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_select_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_select_post[hIndex].func; - postHookFunc(&fd, sd, &ipl); + postHookFunc(fd, sd, ipl); } } return; @@ -3304,10 +3304,10 @@ void HP_chr_creation_failed(int fd, int result) { HPMHooks.source.chr.creation_failed(fd, result); } if( HPMHooks.count.HP_chr_creation_failed_post ) { - void (*postHookFunc) (int *fd, int *result); + void (*postHookFunc) (int fd, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_creation_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_creation_failed_post[hIndex].func; - postHookFunc(&fd, &result); + postHookFunc(fd, result); } } return; @@ -3315,11 +3315,11 @@ void HP_chr_creation_failed(int fd, int result) { void HP_chr_creation_ok(int fd, struct mmo_charstatus *char_dat) { int hIndex = 0; if( HPMHooks.count.HP_chr_creation_ok_pre ) { - void (*preHookFunc) (int *fd, struct mmo_charstatus *char_dat); + void (*preHookFunc) (int *fd, struct mmo_charstatus **char_dat); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_creation_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_creation_ok_pre[hIndex].func; - preHookFunc(&fd, char_dat); + preHookFunc(&fd, &char_dat); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3330,10 +3330,10 @@ void HP_chr_creation_ok(int fd, struct mmo_charstatus *char_dat) { HPMHooks.source.chr.creation_ok(fd, char_dat); } if( HPMHooks.count.HP_chr_creation_ok_post ) { - void (*postHookFunc) (int *fd, struct mmo_charstatus *char_dat); + void (*postHookFunc) (int fd, struct mmo_charstatus *char_dat); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_creation_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_creation_ok_post[hIndex].func; - postHookFunc(&fd, char_dat); + postHookFunc(fd, char_dat); } } return; @@ -3341,11 +3341,11 @@ void HP_chr_creation_ok(int fd, struct mmo_charstatus *char_dat) { void HP_chr_parse_char_create_new_char(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_create_new_char_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_create_new_char_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_create_new_char_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3356,10 +3356,10 @@ void HP_chr_parse_char_create_new_char(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_create_new_char(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_create_new_char_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_create_new_char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_create_new_char_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3382,10 +3382,10 @@ void HP_chr_delete_char_failed(int fd, int flag) { HPMHooks.source.chr.delete_char_failed(fd, flag); } if( HPMHooks.count.HP_chr_delete_char_failed_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete_char_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete_char_failed_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -3408,10 +3408,10 @@ void HP_chr_delete_char_ok(int fd) { HPMHooks.source.chr.delete_char_ok(fd); } if( HPMHooks.count.HP_chr_delete_char_ok_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_delete_char_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_delete_char_ok_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3419,11 +3419,11 @@ void HP_chr_delete_char_ok(int fd) { void HP_chr_parse_char_delete_char(int fd, struct char_session_data *sd, unsigned short cmd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_delete_char_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd, unsigned short *cmd); + void (*preHookFunc) (int *fd, struct char_session_data **sd, unsigned short *cmd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete_char_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_delete_char_pre[hIndex].func; - preHookFunc(&fd, sd, &cmd); + preHookFunc(&fd, &sd, &cmd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3434,10 +3434,10 @@ void HP_chr_parse_char_delete_char(int fd, struct char_session_data *sd, unsigne HPMHooks.source.chr.parse_char_delete_char(fd, sd, cmd); } if( HPMHooks.count.HP_chr_parse_char_delete_char_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd, unsigned short *cmd); + void (*postHookFunc) (int fd, struct char_session_data *sd, unsigned short cmd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete_char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_delete_char_post[hIndex].func; - postHookFunc(&fd, sd, &cmd); + postHookFunc(fd, sd, cmd); } } return; @@ -3460,10 +3460,10 @@ void HP_chr_parse_char_ping(int fd) { HPMHooks.source.chr.parse_char_ping(fd); } if( HPMHooks.count.HP_chr_parse_char_ping_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_ping_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_ping_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3486,10 +3486,10 @@ void HP_chr_allow_rename(int fd, int flag) { HPMHooks.source.chr.allow_rename(fd, flag); } if( HPMHooks.count.HP_chr_allow_rename_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_allow_rename_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_allow_rename_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -3497,11 +3497,11 @@ void HP_chr_allow_rename(int fd, int flag) { void HP_chr_parse_char_rename_char(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_rename_char_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3512,10 +3512,10 @@ void HP_chr_parse_char_rename_char(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_rename_char(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_rename_char_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3523,11 +3523,11 @@ void HP_chr_parse_char_rename_char(int fd, struct char_session_data *sd) { void HP_chr_parse_char_rename_char2(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_rename_char2_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3538,10 +3538,10 @@ void HP_chr_parse_char_rename_char2(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_rename_char2(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_rename_char2_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3564,10 +3564,10 @@ void HP_chr_rename_char_ack(int fd, int flag) { HPMHooks.source.chr.rename_char_ack(fd, flag); } if( HPMHooks.count.HP_chr_rename_char_ack_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_rename_char_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_rename_char_ack_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -3575,11 +3575,11 @@ void HP_chr_rename_char_ack(int fd, int flag) { void HP_chr_parse_char_rename_char_confirm(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_rename_char_confirm_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char_confirm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char_confirm_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3590,10 +3590,10 @@ void HP_chr_parse_char_rename_char_confirm(int fd, struct char_session_data *sd) HPMHooks.source.chr.parse_char_rename_char_confirm(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_rename_char_confirm_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_rename_char_confirm_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_rename_char_confirm_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3616,10 +3616,10 @@ void HP_chr_captcha_notsupported(int fd) { HPMHooks.source.chr.captcha_notsupported(fd); } if( HPMHooks.count.HP_chr_captcha_notsupported_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_captcha_notsupported_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_captcha_notsupported_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3642,10 +3642,10 @@ void HP_chr_parse_char_request_captcha(int fd) { HPMHooks.source.chr.parse_char_request_captcha(fd); } if( HPMHooks.count.HP_chr_parse_char_request_captcha_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_request_captcha_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_request_captcha_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3668,10 +3668,10 @@ void HP_chr_parse_char_check_captcha(int fd) { HPMHooks.source.chr.parse_char_check_captcha(fd); } if( HPMHooks.count.HP_chr_parse_char_check_captcha_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_check_captcha_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_check_captcha_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3679,11 +3679,11 @@ void HP_chr_parse_char_check_captcha(int fd) { void HP_chr_parse_char_delete2_req(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_delete2_req_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_req_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_req_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3694,10 +3694,10 @@ void HP_chr_parse_char_delete2_req(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_delete2_req(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_delete2_req_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_req_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3705,11 +3705,11 @@ void HP_chr_parse_char_delete2_req(int fd, struct char_session_data *sd) { void HP_chr_parse_char_delete2_accept(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_delete2_accept_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_accept_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_accept_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3720,10 +3720,10 @@ void HP_chr_parse_char_delete2_accept(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_delete2_accept(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_delete2_accept_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_accept_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_accept_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3731,11 +3731,11 @@ void HP_chr_parse_char_delete2_accept(int fd, struct char_session_data *sd) { void HP_chr_parse_char_delete2_cancel(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_delete2_cancel_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_cancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_cancel_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3746,10 +3746,10 @@ void HP_chr_parse_char_delete2_cancel(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_delete2_cancel(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_delete2_cancel_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_delete2_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_delete2_cancel_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3772,10 +3772,10 @@ void HP_chr_login_map_server_ack(int fd, uint8 flag) { HPMHooks.source.chr.login_map_server_ack(fd, flag); } if( HPMHooks.count.HP_chr_login_map_server_ack_post ) { - void (*postHookFunc) (int *fd, uint8 *flag); + void (*postHookFunc) (int fd, uint8 flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_login_map_server_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_login_map_server_ack_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -3798,10 +3798,10 @@ void HP_chr_parse_char_login_map_server(int fd, uint32 ipl) { HPMHooks.source.chr.parse_char_login_map_server(fd, ipl); } if( HPMHooks.count.HP_chr_parse_char_login_map_server_post ) { - void (*postHookFunc) (int *fd, uint32 *ipl); + void (*postHookFunc) (int fd, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_login_map_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_login_map_server_post[hIndex].func; - postHookFunc(&fd, &ipl); + postHookFunc(fd, ipl); } } return; @@ -3809,11 +3809,11 @@ void HP_chr_parse_char_login_map_server(int fd, uint32 ipl) { void HP_chr_parse_char_pincode_check(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_pincode_check_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_check_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3824,10 +3824,10 @@ void HP_chr_parse_char_pincode_check(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_pincode_check(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_pincode_check_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_check_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3835,11 +3835,11 @@ void HP_chr_parse_char_pincode_check(int fd, struct char_session_data *sd) { void HP_chr_parse_char_pincode_window(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_pincode_window_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_window_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_window_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3850,10 +3850,10 @@ void HP_chr_parse_char_pincode_window(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_pincode_window(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_pincode_window_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_window_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_window_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3861,11 +3861,11 @@ void HP_chr_parse_char_pincode_window(int fd, struct char_session_data *sd) { void HP_chr_parse_char_pincode_change(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_pincode_change_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_change_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3876,10 +3876,10 @@ void HP_chr_parse_char_pincode_change(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_pincode_change(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_pincode_change_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_change_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3887,11 +3887,11 @@ void HP_chr_parse_char_pincode_change(int fd, struct char_session_data *sd) { void HP_chr_parse_char_pincode_first_pin(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_pincode_first_pin_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_first_pin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_first_pin_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3902,10 +3902,10 @@ void HP_chr_parse_char_pincode_first_pin(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_pincode_first_pin(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_pincode_first_pin_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_pincode_first_pin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_pincode_first_pin_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3913,11 +3913,11 @@ void HP_chr_parse_char_pincode_first_pin(int fd, struct char_session_data *sd) { void HP_chr_parse_char_request_chars(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_request_chars_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_request_chars_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_request_chars_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3928,10 +3928,10 @@ void HP_chr_parse_char_request_chars(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_request_chars(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_request_chars_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_request_chars_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_request_chars_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -3954,10 +3954,10 @@ void HP_chr_change_character_slot_ack(int fd, bool ret) { HPMHooks.source.chr.change_character_slot_ack(fd, ret); } if( HPMHooks.count.HP_chr_change_character_slot_ack_post ) { - void (*postHookFunc) (int *fd, bool *ret); + void (*postHookFunc) (int fd, bool ret); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_change_character_slot_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_change_character_slot_ack_post[hIndex].func; - postHookFunc(&fd, &ret); + postHookFunc(fd, ret); } } return; @@ -3965,11 +3965,11 @@ void HP_chr_change_character_slot_ack(int fd, bool ret) { void HP_chr_parse_char_move_character(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_chr_parse_char_move_character_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_move_character_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_parse_char_move_character_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3980,10 +3980,10 @@ void HP_chr_parse_char_move_character(int fd, struct char_session_data *sd) { HPMHooks.source.chr.parse_char_move_character(fd, sd); } if( HPMHooks.count.HP_chr_parse_char_move_character_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_move_character_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_move_character_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -4007,10 +4007,10 @@ int HP_chr_parse_char_unknown_packet(int fd, uint32 ipl) { retVal___ = HPMHooks.source.chr.parse_char_unknown_packet(fd, ipl); } if( HPMHooks.count.HP_chr_parse_char_unknown_packet_post ) { - int (*postHookFunc) (int retVal___, int *fd, uint32 *ipl); + int (*postHookFunc) (int retVal___, int fd, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_unknown_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_unknown_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &ipl); + retVal___ = postHookFunc(retVal___, fd, ipl); } } return retVal___; @@ -4034,10 +4034,10 @@ int HP_chr_parse_char(int fd) { retVal___ = HPMHooks.source.chr.parse_char(fd); } if( HPMHooks.count.HP_chr_parse_char_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_parse_char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_parse_char_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -4061,10 +4061,10 @@ int HP_chr_broadcast_user_count(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chr.broadcast_user_count(tid, tick, id, data); } if( HPMHooks.count.HP_chr_broadcast_user_count_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_broadcast_user_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_broadcast_user_count_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -4073,12 +4073,12 @@ int HP_chr_send_accounts_tologin_sub(union DBKey key, struct DBData *data, va_li int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_send_accounts_tologin_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_accounts_tologin_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chr_send_accounts_tologin_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -4092,11 +4092,11 @@ int HP_chr_send_accounts_tologin_sub(union DBKey key, struct DBData *data, va_li va_end(ap___copy); } if( HPMHooks.count.HP_chr_send_accounts_tologin_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_accounts_tologin_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chr_send_accounts_tologin_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -4121,10 +4121,10 @@ int HP_chr_send_accounts_tologin(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chr.send_accounts_tologin(tid, tick, id, data); } if( HPMHooks.count.HP_chr_send_accounts_tologin_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_send_accounts_tologin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_send_accounts_tologin_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -4148,10 +4148,10 @@ int HP_chr_check_connect_login_server(int tid, int64 tick, int id, intptr_t data retVal___ = HPMHooks.source.chr.check_connect_login_server(tid, tick, id, data); } if( HPMHooks.count.HP_chr_check_connect_login_server_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_check_connect_login_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_check_connect_login_server_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -4160,12 +4160,12 @@ int HP_chr_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_online_data_cleanup_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_online_data_cleanup_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chr_online_data_cleanup_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -4179,11 +4179,11 @@ int HP_chr_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_list va_end(ap___copy); } if( HPMHooks.count.HP_chr_online_data_cleanup_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_online_data_cleanup_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chr_online_data_cleanup_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -4208,10 +4208,10 @@ int HP_chr_online_data_cleanup(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chr.online_data_cleanup(tid, tick, id, data); } if( HPMHooks.count.HP_chr_online_data_cleanup_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_online_data_cleanup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chr_online_data_cleanup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -4219,11 +4219,11 @@ int HP_chr_online_data_cleanup(int tid, int64 tick, int id, intptr_t data) { void HP_chr_sql_config_read(const char *cfgName) { int hIndex = 0; if( HPMHooks.count.HP_chr_sql_config_read_pre ) { - void (*preHookFunc) (const char *cfgName); + void (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_sql_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_sql_config_read_pre[hIndex].func; - preHookFunc(cfgName); + preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4245,11 +4245,11 @@ void HP_chr_sql_config_read(const char *cfgName) { void HP_chr_config_dispatch(char *w1, char *w2) { int hIndex = 0; if( HPMHooks.count.HP_chr_config_dispatch_pre ) { - void (*preHookFunc) (char *w1, char *w2); + void (*preHookFunc) (char **w1, char **w2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_config_dispatch_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_config_dispatch_pre[hIndex].func; - preHookFunc(w1, w2); + preHookFunc(&w1, &w2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4272,11 +4272,11 @@ int HP_chr_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chr_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chr_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chr_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4352,11 +4352,11 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_add_pre ) { - bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*preHookFunc) (unsigned int *pluginID, const char **name, char *shortname, CmdlineExecFunc *func, const char **help, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; - retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + retVal___ = preHookFunc(&pluginID, &name, &shortname, &func, &help, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4367,10 +4367,10 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); } if( HPMHooks.count.HP_cmdline_arg_add_post ) { - bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*postHookFunc) (bool retVal___, unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + retVal___ = postHookFunc(retVal___, pluginID, name, shortname, func, help, options); } } return retVal___; @@ -4379,11 +4379,11 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_cmdline_exec_pre ) { - int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + int (*preHookFunc) (int *argc, char ***argv, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; - retVal___ = preHookFunc(&argc, argv, &options); + retVal___ = preHookFunc(&argc, &argv, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4394,10 +4394,10 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); } if( HPMHooks.count.HP_cmdline_exec_post ) { - int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + int (*postHookFunc) (int retVal___, int argc, char **argv, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &argc, argv, &options); + retVal___ = postHookFunc(retVal___, argc, argv, options); } } return retVal___; @@ -4406,11 +4406,11 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { - bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + bool (*preHookFunc) (const char **name, int *current_arg, int *argc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; - retVal___ = preHookFunc(name, ¤t_arg, &argc); + retVal___ = preHookFunc(&name, ¤t_arg, &argc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4421,10 +4421,10 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); } if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { - bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + bool (*postHookFunc) (bool retVal___, const char *name, int current_arg, int argc); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + retVal___ = postHookFunc(retVal___, name, current_arg, argc); } } return retVal___; @@ -4433,11 +4433,11 @@ const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_cmdline_arg_source_pre ) { - const char* (*preHookFunc) (struct CmdlineArgData *arg); + const char* (*preHookFunc) (struct CmdlineArgData **arg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; - retVal___ = preHookFunc(arg); + retVal___ = preHookFunc(&arg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4608,10 +4608,10 @@ enum DBOptions HP_DB_fix_options(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.fix_options(type, options); } if( HPMHooks.count.HP_DB_fix_options_post ) { - enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType *type, enum DBOptions *options); + enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -4635,10 +4635,10 @@ DBComparator HP_DB_default_cmp(enum DBType type) { retVal___ = HPMHooks.source.DB.default_cmp(type); } if( HPMHooks.count.HP_DB_default_cmp_post ) { - DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType *type); + DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -4662,10 +4662,10 @@ DBHasher HP_DB_default_hash(enum DBType type) { retVal___ = HPMHooks.source.DB.default_hash(type); } if( HPMHooks.count.HP_DB_default_hash_post ) { - DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType *type); + DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -4689,10 +4689,10 @@ DBReleaser HP_DB_default_release(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.default_release(type, options); } if( HPMHooks.count.HP_DB_default_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType *type, enum DBOptions *options); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -4716,10 +4716,10 @@ DBReleaser HP_DB_custom_release(enum DBReleaseOption which) { retVal___ = HPMHooks.source.DB.custom_release(which); } if( HPMHooks.count.HP_DB_custom_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption *which); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption which); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &which); + retVal___ = postHookFunc(retVal___, which); } } return retVal___; @@ -4728,11 +4728,11 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT int hIndex = 0; struct DBMap* retVal___ = NULL; if( HPMHooks.count.HP_DB_alloc_pre ) { - struct DBMap* (*preHookFunc) (const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*preHookFunc) (const char **file, const char **func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; - retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + retVal___ = preHookFunc(&file, &func, &line, &type, &options, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4743,18 +4743,17 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); } if( HPMHooks.count.HP_DB_alloc_post ) { - struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + retVal___ = postHookFunc(retVal___, file, func, line, type, options, maxlen); } } return retVal___; } union DBKey HP_DB_i2key(int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2key_pre ) { union DBKey (*preHookFunc) (int *key); *HPMforce_return = false; @@ -4771,18 +4770,17 @@ union DBKey HP_DB_i2key(int key) { retVal___ = HPMHooks.source.DB.i2key(key); } if( HPMHooks.count.HP_DB_i2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui2key(unsigned int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2key_pre ) { union DBKey (*preHookFunc) (unsigned int *key); *HPMforce_return = false; @@ -4799,24 +4797,23 @@ union DBKey HP_DB_ui2key(unsigned int key) { retVal___ = HPMHooks.source.DB.ui2key(key); } if( HPMHooks.count.HP_DB_ui2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_str2key(const char *key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_str2key_pre ) { - union DBKey (*preHookFunc) (const char *key); + union DBKey (*preHookFunc) (const char **key); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; - retVal___ = preHookFunc(key); + retVal___ = preHookFunc(&key); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4837,8 +4834,7 @@ union DBKey HP_DB_str2key(const char *key) { } union DBKey HP_DB_i642key(int64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i642key_pre ) { union DBKey (*preHookFunc) (int64 *key); *HPMforce_return = false; @@ -4855,18 +4851,17 @@ union DBKey HP_DB_i642key(int64 key) { retVal___ = HPMHooks.source.DB.i642key(key); } if( HPMHooks.count.HP_DB_i642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui642key(uint64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui642key_pre ) { union DBKey (*preHookFunc) (uint64 *key); *HPMforce_return = false; @@ -4883,18 +4878,17 @@ union DBKey HP_DB_ui642key(uint64 key) { retVal___ = HPMHooks.source.DB.ui642key(key); } if( HPMHooks.count.HP_DB_ui642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, uint64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, uint64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } struct DBData HP_DB_i2data(int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2data_pre ) { struct DBData (*preHookFunc) (int *data); *HPMforce_return = false; @@ -4911,18 +4905,17 @@ struct DBData HP_DB_i2data(int data) { retVal___ = HPMHooks.source.DB.i2data(data); } if( HPMHooks.count.HP_DB_i2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ui2data(unsigned int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2data_pre ) { struct DBData (*preHookFunc) (unsigned int *data); *HPMforce_return = false; @@ -4939,24 +4932,23 @@ struct DBData HP_DB_ui2data(unsigned int data) { retVal___ = HPMHooks.source.DB.ui2data(data); } if( HPMHooks.count.HP_DB_ui2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ptr2data(void *data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ptr2data_pre ) { - struct DBData (*preHookFunc) (void *data); + struct DBData (*preHookFunc) (void **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4979,11 +4971,11 @@ int HP_DB_data2i(struct DBData *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_DB_data2i_pre ) { - int (*preHookFunc) (struct DBData *data); + int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5006,11 +4998,11 @@ unsigned int HP_DB_data2ui(struct DBData *data) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_DB_data2ui_pre ) { - unsigned int (*preHookFunc) (struct DBData *data); + unsigned int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5033,11 +5025,11 @@ void* HP_DB_data2ptr(struct DBData *data) { int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_DB_data2ptr_pre ) { - void* (*preHookFunc) (struct DBData *data); + void* (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5128,10 +5120,10 @@ const char* HP_geoip_getcountry(uint32 ipnum) { retVal___ = HPMHooks.source.geoip.getcountry(ipnum); } if( HPMHooks.count.HP_geoip_getcountry_post ) { - const char* (*postHookFunc) (const char* retVal___, uint32 *ipnum); + const char* (*postHookFunc) (const char* retVal___, uint32 ipnum); for(hIndex = 0; hIndex < HPMHooks.count.HP_geoip_getcountry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_geoip_getcountry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ipnum); + retVal___ = postHookFunc(retVal___, ipnum); } } return retVal___; @@ -5154,10 +5146,10 @@ void HP_geoip_final(bool shutdown) { HPMHooks.source.geoip.final(shutdown); } if( HPMHooks.count.HP_geoip_final_post ) { - void (*postHookFunc) (bool *shutdown); + void (*postHookFunc) (bool shutdown); for(hIndex = 0; hIndex < HPMHooks.count.HP_geoip_final_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_geoip_final_post[hIndex].func; - postHookFunc(&shutdown); + postHookFunc(shutdown); } } return; @@ -5208,10 +5200,10 @@ int HP_inter_auction_count(int char_id, bool buy) { retVal___ = HPMHooks.source.inter_auction.count(char_id, buy); } if( HPMHooks.count.HP_inter_auction_count_post ) { - int (*postHookFunc) (int retVal___, int *char_id, bool *buy); + int (*postHookFunc) (int retVal___, int char_id, bool buy); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_auction_count_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &buy); + retVal___ = postHookFunc(retVal___, char_id, buy); } } return retVal___; @@ -5219,11 +5211,11 @@ int HP_inter_auction_count(int char_id, bool buy) { void HP_inter_auction_save(struct auction_data *auction) { int hIndex = 0; if( HPMHooks.count.HP_inter_auction_save_pre ) { - void (*preHookFunc) (struct auction_data *auction); + void (*preHookFunc) (struct auction_data **auction); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_auction_save_pre[hIndex].func; - preHookFunc(auction); + preHookFunc(&auction); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5246,11 +5238,11 @@ unsigned int HP_inter_auction_create(struct auction_data *auction) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_inter_auction_create_pre ) { - unsigned int (*preHookFunc) (struct auction_data *auction); + unsigned int (*preHookFunc) (struct auction_data **auction); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_auction_create_pre[hIndex].func; - retVal___ = preHookFunc(auction); + retVal___ = preHookFunc(&auction); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5288,10 +5280,10 @@ int HP_inter_auction_end_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.inter_auction.end_timer(tid, tick, id, data); } if( HPMHooks.count.HP_inter_auction_end_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_end_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_auction_end_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -5299,11 +5291,11 @@ int HP_inter_auction_end_timer(int tid, int64 tick, int id, intptr_t data) { void HP_inter_auction_delete_(struct auction_data *auction) { int hIndex = 0; if( HPMHooks.count.HP_inter_auction_delete__pre ) { - void (*preHookFunc) (struct auction_data *auction); + void (*preHookFunc) (struct auction_data **auction); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_delete__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_auction_delete__pre[hIndex].func; - preHookFunc(auction); + preHookFunc(&auction); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5367,10 +5359,10 @@ int HP_inter_auction_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_auction.parse_frommap(fd); } if( HPMHooks.count.HP_inter_auction_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_auction_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_auction_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5500,10 +5492,10 @@ int HP_inter_elemental_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_elemental.parse_frommap(fd); } if( HPMHooks.count.HP_inter_elemental_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_elemental_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_elemental_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5528,10 +5520,10 @@ int HP_inter_guild_save_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.inter_guild.save_timer(tid, tick, id, data); } if( HPMHooks.count.HP_inter_guild_save_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_save_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_save_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -5555,10 +5547,10 @@ int HP_inter_guild_removemember_tosql(int account_id, int char_id) { retVal___ = HPMHooks.source.inter_guild.removemember_tosql(account_id, char_id); } if( HPMHooks.count.HP_inter_guild_removemember_tosql_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_removemember_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_removemember_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, account_id, char_id); } } return retVal___; @@ -5567,11 +5559,11 @@ int HP_inter_guild_tosql(struct guild *g, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_tosql_pre ) { - int (*preHookFunc) (struct guild *g, int *flag); + int (*preHookFunc) (struct guild **g, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_tosql_pre[hIndex].func; - retVal___ = preHookFunc(g, &flag); + retVal___ = preHookFunc(&g, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5582,10 +5574,10 @@ int HP_inter_guild_tosql(struct guild *g, int flag) { retVal___ = HPMHooks.source.inter_guild.tosql(g, flag); } if( HPMHooks.count.HP_inter_guild_tosql_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *flag); + int (*postHookFunc) (int retVal___, struct guild *g, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &flag); + retVal___ = postHookFunc(retVal___, g, flag); } } return retVal___; @@ -5609,10 +5601,10 @@ struct guild* HP_inter_guild_fromsql(int guild_id) { retVal___ = HPMHooks.source.inter_guild.fromsql(guild_id); } if( HPMHooks.count.HP_inter_guild_fromsql_post ) { - struct guild* (*postHookFunc) (struct guild* retVal___, int *guild_id); + struct guild* (*postHookFunc) (struct guild* retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -5621,11 +5613,11 @@ int HP_inter_guild_castle_tosql(struct guild_castle *gc) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_castle_tosql_pre ) { - int (*preHookFunc) (struct guild_castle *gc); + int (*preHookFunc) (struct guild_castle **gc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_castle_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_castle_tosql_pre[hIndex].func; - retVal___ = preHookFunc(gc); + retVal___ = preHookFunc(&gc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5663,10 +5655,10 @@ struct guild_castle* HP_inter_guild_castle_fromsql(int castle_id) { retVal___ = HPMHooks.source.inter_guild.castle_fromsql(castle_id); } if( HPMHooks.count.HP_inter_guild_castle_fromsql_post ) { - struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int *castle_id); + struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int castle_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_castle_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_castle_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &castle_id); + retVal___ = postHookFunc(retVal___, castle_id); } } return retVal___; @@ -5675,11 +5667,11 @@ bool HP_inter_guild_exp_parse_row(char *split[], int column, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_guild_exp_parse_row_pre ) { - bool (*preHookFunc) (char *split[], int *column, int *current); + bool (*preHookFunc) (char **split[], int *column, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_exp_parse_row_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_exp_parse_row_pre[hIndex].func; - retVal___ = preHookFunc(split, &column, ¤t); + retVal___ = preHookFunc(&split, &column, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5690,10 +5682,10 @@ bool HP_inter_guild_exp_parse_row(char *split[], int column, int current) { retVal___ = HPMHooks.source.inter_guild.exp_parse_row(split, column, current); } if( HPMHooks.count.HP_inter_guild_exp_parse_row_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *column, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int column, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_exp_parse_row_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_exp_parse_row_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &column, ¤t); + retVal___ = postHookFunc(retVal___, split, column, current); } } return retVal___; @@ -5717,10 +5709,10 @@ int HP_inter_guild_CharOnline(int char_id, int guild_id) { retVal___ = HPMHooks.source.inter_guild.CharOnline(char_id, guild_id); } if( HPMHooks.count.HP_inter_guild_CharOnline_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *guild_id); + int (*postHookFunc) (int retVal___, int char_id, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_CharOnline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_CharOnline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &guild_id); + retVal___ = postHookFunc(retVal___, char_id, guild_id); } } return retVal___; @@ -5744,10 +5736,10 @@ int HP_inter_guild_CharOffline(int char_id, int guild_id) { retVal___ = HPMHooks.source.inter_guild.CharOffline(char_id, guild_id); } if( HPMHooks.count.HP_inter_guild_CharOffline_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *guild_id); + int (*postHookFunc) (int retVal___, int char_id, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_CharOffline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_CharOffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &guild_id); + retVal___ = postHookFunc(retVal___, char_id, guild_id); } } return retVal___; @@ -5783,12 +5775,12 @@ int HP_inter_guild_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_inter_guild_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5802,11 +5794,11 @@ int HP_inter_guild_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_inter_guild_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_inter_guild_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -5842,11 +5834,11 @@ int HP_inter_guild_search_guildname(const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_search_guildname_pre ) { - int (*preHookFunc) (const char *str); + int (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_search_guildname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_search_guildname_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5869,11 +5861,11 @@ bool HP_inter_guild_check_empty(struct guild *g) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_guild_check_empty_pre ) { - bool (*preHookFunc) (struct guild *g); + bool (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_check_empty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_check_empty_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5911,10 +5903,10 @@ unsigned int HP_inter_guild_nextexp(int level) { retVal___ = HPMHooks.source.inter_guild.nextexp(level); } if( HPMHooks.count.HP_inter_guild_nextexp_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, int *level); + unsigned int (*postHookFunc) (unsigned int retVal___, int level); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_nextexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_nextexp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &level); + retVal___ = postHookFunc(retVal___, level); } } return retVal___; @@ -5923,11 +5915,11 @@ int HP_inter_guild_checkskill(struct guild *g, int id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_checkskill_pre ) { - int (*preHookFunc) (struct guild *g, int *id); + int (*preHookFunc) (struct guild **g, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_checkskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_checkskill_pre[hIndex].func; - retVal___ = preHookFunc(g, &id); + retVal___ = preHookFunc(&g, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5938,10 +5930,10 @@ int HP_inter_guild_checkskill(struct guild *g, int id) { retVal___ = HPMHooks.source.inter_guild.checkskill(g, id); } if( HPMHooks.count.HP_inter_guild_checkskill_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *id); + int (*postHookFunc) (int retVal___, struct guild *g, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_checkskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_checkskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &id); + retVal___ = postHookFunc(retVal___, g, id); } } return retVal___; @@ -5950,11 +5942,11 @@ int HP_inter_guild_calcinfo(struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_calcinfo_pre ) { - int (*preHookFunc) (struct guild *g); + int (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_calcinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_calcinfo_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5992,10 +5984,10 @@ int HP_inter_guild_sex_changed(int guild_id, int account_id, int char_id, short retVal___ = HPMHooks.source.inter_guild.sex_changed(guild_id, account_id, char_id, gender); } if( HPMHooks.count.HP_inter_guild_sex_changed_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, short *gender); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, short gender); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_sex_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_sex_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &gender); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, gender); } } return retVal___; @@ -6004,11 +5996,11 @@ int HP_inter_guild_charname_changed(int guild_id, int account_id, int char_id, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_guild_charname_changed_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, char *name); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_charname_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_guild_charname_changed_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, name); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6019,10 +6011,10 @@ int HP_inter_guild_charname_changed(int guild_id, int account_id, int char_id, c retVal___ = HPMHooks.source.inter_guild.charname_changed(guild_id, account_id, char_id, name); } if( HPMHooks.count.HP_inter_guild_charname_changed_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, char *name); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_charname_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_charname_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, name); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, name); } } return retVal___; @@ -6046,10 +6038,10 @@ int HP_inter_guild_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_guild.parse_frommap(fd); } if( HPMHooks.count.HP_inter_guild_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6073,10 +6065,10 @@ int HP_inter_guild_leave(int guild_id, int account_id, int char_id) { retVal___ = HPMHooks.source.inter_guild.leave(guild_id, account_id, char_id); } if( HPMHooks.count.HP_inter_guild_leave_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id); } } return retVal___; @@ -6100,10 +6092,10 @@ int HP_inter_guild_broken(int guild_id) { retVal___ = HPMHooks.source.inter_guild.broken(guild_id); } if( HPMHooks.count.HP_inter_guild_broken_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_guild_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_guild_broken_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -6181,10 +6173,10 @@ int HP_inter_homunculus_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_homunculus.parse_frommap(fd); } if( HPMHooks.count.HP_inter_homunculus_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_homunculus_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_homunculus_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6209,10 +6201,10 @@ const char* HP_inter_msg_txt(int msg_number) { retVal___ = HPMHooks.source.inter.msg_txt(msg_number); } if( HPMHooks.count.HP_inter_msg_txt_post ) { - const char* (*postHookFunc) (const char* retVal___, int *msg_number); + const char* (*postHookFunc) (const char* retVal___, int msg_number); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_msg_txt_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_msg_txt_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &msg_number); + retVal___ = postHookFunc(retVal___, msg_number); } } return retVal___; @@ -6221,11 +6213,11 @@ bool HP_inter_msg_config_read(const char *cfg_name, bool allow_override) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_msg_config_read_pre ) { - bool (*preHookFunc) (const char *cfg_name, bool *allow_override); + bool (*preHookFunc) (const char **cfg_name, bool *allow_override); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_msg_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_msg_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfg_name, &allow_override); + retVal___ = preHookFunc(&cfg_name, &allow_override); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6236,10 +6228,10 @@ bool HP_inter_msg_config_read(const char *cfg_name, bool allow_override) { retVal___ = HPMHooks.source.inter.msg_config_read(cfg_name, allow_override); } if( HPMHooks.count.HP_inter_msg_config_read_post ) { - bool (*postHookFunc) (bool retVal___, const char *cfg_name, bool *allow_override); + bool (*postHookFunc) (bool retVal___, const char *cfg_name, bool allow_override); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_msg_config_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_msg_config_read_post[hIndex].func; - retVal___ = postHookFunc(retVal___, cfg_name, &allow_override); + retVal___ = postHookFunc(retVal___, cfg_name, allow_override); } } return retVal___; @@ -6289,10 +6281,10 @@ const char* HP_inter_job_name(int class_) { retVal___ = HPMHooks.source.inter.job_name(class_); } if( HPMHooks.count.HP_inter_job_name_post ) { - const char* (*postHookFunc) (const char* retVal___, int *class_); + const char* (*postHookFunc) (const char* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_job_name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_job_name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -6300,12 +6292,12 @@ const char* HP_inter_job_name(int class_) { void HP_inter_vmsg_to_fd(int fd, int u_fd, int aid, char *msg, va_list ap) { int hIndex = 0; if( HPMHooks.count.HP_inter_vmsg_to_fd_pre ) { - void (*preHookFunc) (int *fd, int *u_fd, int *aid, char *msg, va_list ap); + void (*preHookFunc) (int *fd, int *u_fd, int *aid, char **msg, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_vmsg_to_fd_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_inter_vmsg_to_fd_pre[hIndex].func; - preHookFunc(&fd, &u_fd, &aid, msg, ap___copy); + preHookFunc(&fd, &u_fd, &aid, &msg, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -6319,11 +6311,11 @@ void HP_inter_vmsg_to_fd(int fd, int u_fd, int aid, char *msg, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_inter_vmsg_to_fd_post ) { - void (*postHookFunc) (int *fd, int *u_fd, int *aid, char *msg, va_list ap); + void (*postHookFunc) (int fd, int u_fd, int aid, char *msg, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_vmsg_to_fd_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_inter_vmsg_to_fd_post[hIndex].func; - postHookFunc(&fd, &u_fd, &aid, msg, ap___copy); + postHookFunc(fd, u_fd, aid, msg, ap___copy); va_end(ap___copy); } } @@ -6332,11 +6324,11 @@ void HP_inter_vmsg_to_fd(int fd, int u_fd, int aid, char *msg, va_list ap) { void HP_inter_savereg(int account_id, int char_id, const char *key, unsigned int index, intptr_t val, bool is_string) { int hIndex = 0; if( HPMHooks.count.HP_inter_savereg_pre ) { - void (*preHookFunc) (int *account_id, int *char_id, const char *key, unsigned int *index, intptr_t *val, bool *is_string); + void (*preHookFunc) (int *account_id, int *char_id, const char **key, unsigned int *index, intptr_t *val, bool *is_string); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_savereg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_savereg_pre[hIndex].func; - preHookFunc(&account_id, &char_id, key, &index, &val, &is_string); + preHookFunc(&account_id, &char_id, &key, &index, &val, &is_string); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6347,10 +6339,10 @@ void HP_inter_savereg(int account_id, int char_id, const char *key, unsigned int HPMHooks.source.inter.savereg(account_id, char_id, key, index, val, is_string); } if( HPMHooks.count.HP_inter_savereg_post ) { - void (*postHookFunc) (int *account_id, int *char_id, const char *key, unsigned int *index, intptr_t *val, bool *is_string); + void (*postHookFunc) (int account_id, int char_id, const char *key, unsigned int index, intptr_t val, bool is_string); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_savereg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_savereg_post[hIndex].func; - postHookFunc(&account_id, &char_id, key, &index, &val, &is_string); + postHookFunc(account_id, char_id, key, index, val, is_string); } } return; @@ -6374,10 +6366,10 @@ int HP_inter_accreg_fromsql(int account_id, int char_id, int fd, int type) { retVal___ = HPMHooks.source.inter.accreg_fromsql(account_id, char_id, fd, type); } if( HPMHooks.count.HP_inter_accreg_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *char_id, int *fd, int *type); + int (*postHookFunc) (int retVal___, int account_id, int char_id, int fd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_accreg_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_accreg_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id, &fd, &type); + retVal___ = postHookFunc(retVal___, account_id, char_id, fd, type); } } return retVal___; @@ -6386,11 +6378,11 @@ int HP_inter_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6413,12 +6405,12 @@ int HP_inter_vlog(char *fmt, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_vlog_pre ) { - int (*preHookFunc) (char *fmt, va_list ap); + int (*preHookFunc) (char **fmt, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_vlog_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_inter_vlog_pre[hIndex].func; - retVal___ = preHookFunc(fmt, ap___copy); + retVal___ = preHookFunc(&fmt, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -6446,11 +6438,11 @@ int HP_inter_init_sql(const char *file) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_init_sql_pre ) { - int (*preHookFunc) (const char *file); + int (*preHookFunc) (const char **file); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_init_sql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_init_sql_pre[hIndex].func; - retVal___ = preHookFunc(file); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6488,10 +6480,10 @@ int HP_inter_mapif_init(int fd) { retVal___ = HPMHooks.source.inter.mapif_init(fd); } if( HPMHooks.count.HP_inter_mapif_init_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mapif_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mapif_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6500,12 +6492,12 @@ int HP_inter_check_ttl_wisdata_sub(union DBKey key, struct DBData *data, va_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_check_ttl_wisdata_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_check_ttl_wisdata_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_inter_check_ttl_wisdata_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -6519,11 +6511,11 @@ int HP_inter_check_ttl_wisdata_sub(union DBKey key, struct DBData *data, va_list va_end(ap___copy); } if( HPMHooks.count.HP_inter_check_ttl_wisdata_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_check_ttl_wisdata_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_inter_check_ttl_wisdata_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -6575,10 +6567,10 @@ int HP_inter_check_length(int fd, int length) { retVal___ = HPMHooks.source.inter.check_length(fd, length); } if( HPMHooks.count.HP_inter_check_length_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *length); + int (*postHookFunc) (int retVal___, int fd, int length); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_check_length_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_check_length_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &length); + retVal___ = postHookFunc(retVal___, fd, length); } } return retVal___; @@ -6602,10 +6594,10 @@ int HP_inter_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter.parse_frommap(fd); } if( HPMHooks.count.HP_inter_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6709,10 +6701,10 @@ int HP_inter_mail_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_mail.parse_frommap(fd); } if( HPMHooks.count.HP_inter_mail_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mail_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6721,11 +6713,11 @@ int HP_inter_mail_fromsql(int char_id, struct mail_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_mail_fromsql_pre ) { - int (*preHookFunc) (int *char_id, struct mail_data *md); + int (*preHookFunc) (int *char_id, struct mail_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mail_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, md); + retVal___ = preHookFunc(&char_id, &md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6736,10 +6728,10 @@ int HP_inter_mail_fromsql(int char_id, struct mail_data *md) { retVal___ = HPMHooks.source.inter_mail.fromsql(char_id, md); } if( HPMHooks.count.HP_inter_mail_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *char_id, struct mail_data *md); + int (*postHookFunc) (int retVal___, int char_id, struct mail_data *md); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mail_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, md); + retVal___ = postHookFunc(retVal___, char_id, md); } } return retVal___; @@ -6748,11 +6740,11 @@ int HP_inter_mail_savemessage(struct mail_message *msg) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_mail_savemessage_pre ) { - int (*preHookFunc) (struct mail_message *msg); + int (*preHookFunc) (struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_savemessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mail_savemessage_pre[hIndex].func; - retVal___ = preHookFunc(msg); + retVal___ = preHookFunc(&msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6775,11 +6767,11 @@ bool HP_inter_mail_loadmessage(int mail_id, struct mail_message *msg) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_mail_loadmessage_pre ) { - bool (*preHookFunc) (int *mail_id, struct mail_message *msg); + bool (*preHookFunc) (int *mail_id, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_loadmessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mail_loadmessage_pre[hIndex].func; - retVal___ = preHookFunc(&mail_id, msg); + retVal___ = preHookFunc(&mail_id, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6790,10 +6782,10 @@ bool HP_inter_mail_loadmessage(int mail_id, struct mail_message *msg) { retVal___ = HPMHooks.source.inter_mail.loadmessage(mail_id, msg); } if( HPMHooks.count.HP_inter_mail_loadmessage_post ) { - bool (*postHookFunc) (bool retVal___, int *mail_id, struct mail_message *msg); + bool (*postHookFunc) (bool retVal___, int mail_id, struct mail_message *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_loadmessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mail_loadmessage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &mail_id, msg); + retVal___ = postHookFunc(retVal___, mail_id, msg); } } return retVal___; @@ -6817,10 +6809,10 @@ bool HP_inter_mail_DeleteAttach(int mail_id) { retVal___ = HPMHooks.source.inter_mail.DeleteAttach(mail_id); } if( HPMHooks.count.HP_inter_mail_DeleteAttach_post ) { - bool (*postHookFunc) (bool retVal___, int *mail_id); + bool (*postHookFunc) (bool retVal___, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_DeleteAttach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mail_DeleteAttach_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &mail_id); + retVal___ = postHookFunc(retVal___, mail_id); } } return retVal___; @@ -6828,11 +6820,11 @@ bool HP_inter_mail_DeleteAttach(int mail_id) { void HP_inter_mail_sendmail(int send_id, const char *send_name, int dest_id, const char *dest_name, const char *title, const char *body, int zeny, struct item *item) { int hIndex = 0; if( HPMHooks.count.HP_inter_mail_sendmail_pre ) { - void (*preHookFunc) (int *send_id, const char *send_name, int *dest_id, const char *dest_name, const char *title, const char *body, int *zeny, struct item *item); + void (*preHookFunc) (int *send_id, const char **send_name, int *dest_id, const char **dest_name, const char **title, const char **body, int *zeny, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_sendmail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mail_sendmail_pre[hIndex].func; - preHookFunc(&send_id, send_name, &dest_id, dest_name, title, body, &zeny, item); + preHookFunc(&send_id, &send_name, &dest_id, &dest_name, &title, &body, &zeny, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6843,10 +6835,10 @@ void HP_inter_mail_sendmail(int send_id, const char *send_name, int dest_id, con HPMHooks.source.inter_mail.sendmail(send_id, send_name, dest_id, dest_name, title, body, zeny, item); } if( HPMHooks.count.HP_inter_mail_sendmail_post ) { - void (*postHookFunc) (int *send_id, const char *send_name, int *dest_id, const char *dest_name, const char *title, const char *body, int *zeny, struct item *item); + void (*postHookFunc) (int send_id, const char *send_name, int dest_id, const char *dest_name, const char *title, const char *body, int zeny, struct item *item); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mail_sendmail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mail_sendmail_post[hIndex].func; - postHookFunc(&send_id, send_name, &dest_id, dest_name, title, body, &zeny, item); + postHookFunc(send_id, send_name, dest_id, dest_name, title, body, zeny, item); } } return; @@ -6856,11 +6848,11 @@ bool HP_inter_mercenary_owner_fromsql(int char_id, struct mmo_charstatus *status int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_mercenary_owner_fromsql_pre ) { - bool (*preHookFunc) (int *char_id, struct mmo_charstatus *status); + bool (*preHookFunc) (int *char_id, struct mmo_charstatus **status); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_owner_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mercenary_owner_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, status); + retVal___ = preHookFunc(&char_id, &status); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6871,10 +6863,10 @@ bool HP_inter_mercenary_owner_fromsql(int char_id, struct mmo_charstatus *status retVal___ = HPMHooks.source.inter_mercenary.owner_fromsql(char_id, status); } if( HPMHooks.count.HP_inter_mercenary_owner_fromsql_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, struct mmo_charstatus *status); + bool (*postHookFunc) (bool retVal___, int char_id, struct mmo_charstatus *status); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_owner_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mercenary_owner_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, status); + retVal___ = postHookFunc(retVal___, char_id, status); } } return retVal___; @@ -6883,11 +6875,11 @@ bool HP_inter_mercenary_owner_tosql(int char_id, struct mmo_charstatus *status) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_inter_mercenary_owner_tosql_pre ) { - bool (*preHookFunc) (int *char_id, struct mmo_charstatus *status); + bool (*preHookFunc) (int *char_id, struct mmo_charstatus **status); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_owner_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_mercenary_owner_tosql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, status); + retVal___ = preHookFunc(&char_id, &status); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6898,10 +6890,10 @@ bool HP_inter_mercenary_owner_tosql(int char_id, struct mmo_charstatus *status) retVal___ = HPMHooks.source.inter_mercenary.owner_tosql(char_id, status); } if( HPMHooks.count.HP_inter_mercenary_owner_tosql_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, struct mmo_charstatus *status); + bool (*postHookFunc) (bool retVal___, int char_id, struct mmo_charstatus *status); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_owner_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mercenary_owner_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, status); + retVal___ = postHookFunc(retVal___, char_id, status); } } return retVal___; @@ -6925,10 +6917,10 @@ bool HP_inter_mercenary_owner_delete(int char_id) { retVal___ = HPMHooks.source.inter_mercenary.owner_delete(char_id); } if( HPMHooks.count.HP_inter_mercenary_owner_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id); + bool (*postHookFunc) (bool retVal___, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_owner_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mercenary_owner_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id); + retVal___ = postHookFunc(retVal___, char_id); } } return retVal___; @@ -7005,10 +6997,10 @@ int HP_inter_mercenary_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_mercenary.parse_frommap(fd); } if( HPMHooks.count.HP_inter_mercenary_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_mercenary_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_mercenary_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -7018,11 +7010,11 @@ int HP_inter_party_check_lv(struct party_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_party_check_lv_pre ) { - int (*preHookFunc) (struct party_data *p); + int (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_check_lv_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_check_lv_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7044,11 +7036,11 @@ int HP_inter_party_check_lv(struct party_data *p) { void HP_inter_party_calc_state(struct party_data *p) { int hIndex = 0; if( HPMHooks.count.HP_inter_party_calc_state_pre ) { - void (*preHookFunc) (struct party_data *p); + void (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_calc_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_calc_state_pre[hIndex].func; - preHookFunc(p); + preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7071,11 +7063,11 @@ int HP_inter_party_tosql(struct party *p, int flag, int index) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_party_tosql_pre ) { - int (*preHookFunc) (struct party *p, int *flag, int *index); + int (*preHookFunc) (struct party **p, int *flag, int *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_tosql_pre[hIndex].func; - retVal___ = preHookFunc(p, &flag, &index); + retVal___ = preHookFunc(&p, &flag, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7086,10 +7078,10 @@ int HP_inter_party_tosql(struct party *p, int flag, int index) { retVal___ = HPMHooks.source.inter_party.tosql(p, flag, index); } if( HPMHooks.count.HP_inter_party_tosql_post ) { - int (*postHookFunc) (int retVal___, struct party *p, int *flag, int *index); + int (*postHookFunc) (int retVal___, struct party *p, int flag, int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &flag, &index); + retVal___ = postHookFunc(retVal___, p, flag, index); } } return retVal___; @@ -7113,10 +7105,10 @@ struct party_data* HP_inter_party_fromsql(int party_id) { retVal___ = HPMHooks.source.inter_party.fromsql(party_id); } if( HPMHooks.count.HP_inter_party_fromsql_post ) { - struct party_data* (*postHookFunc) (struct party_data* retVal___, int *party_id); + struct party_data* (*postHookFunc) (struct party_data* retVal___, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id); + retVal___ = postHookFunc(retVal___, party_id); } } return retVal___; @@ -7178,11 +7170,11 @@ struct party_data* HP_inter_party_search_partyname(const char *str) { int hIndex = 0; struct party_data* retVal___ = NULL; if( HPMHooks.count.HP_inter_party_search_partyname_pre ) { - struct party_data* (*preHookFunc) (const char *str); + struct party_data* (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_search_partyname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_search_partyname_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7205,11 +7197,11 @@ int HP_inter_party_check_exp_share(struct party_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_party_check_exp_share_pre ) { - int (*preHookFunc) (struct party_data *p); + int (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_check_exp_share_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_check_exp_share_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7232,11 +7224,11 @@ int HP_inter_party_check_empty(struct party_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_party_check_empty_pre ) { - int (*preHookFunc) (struct party_data *p); + int (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_check_empty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_party_check_empty_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7274,10 +7266,10 @@ int HP_inter_party_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_party.parse_frommap(fd); } if( HPMHooks.count.HP_inter_party_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -7301,10 +7293,10 @@ int HP_inter_party_leave(int party_id, int account_id, int char_id) { retVal___ = HPMHooks.source.inter_party.leave(party_id, account_id, char_id); } if( HPMHooks.count.HP_inter_party_leave_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -7328,10 +7320,10 @@ int HP_inter_party_CharOnline(int char_id, int party_id) { retVal___ = HPMHooks.source.inter_party.CharOnline(char_id, party_id); } if( HPMHooks.count.HP_inter_party_CharOnline_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *party_id); + int (*postHookFunc) (int retVal___, int char_id, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_CharOnline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_CharOnline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &party_id); + retVal___ = postHookFunc(retVal___, char_id, party_id); } } return retVal___; @@ -7355,10 +7347,10 @@ int HP_inter_party_CharOffline(int char_id, int party_id) { retVal___ = HPMHooks.source.inter_party.CharOffline(char_id, party_id); } if( HPMHooks.count.HP_inter_party_CharOffline_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *party_id); + int (*postHookFunc) (int retVal___, int char_id, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_party_CharOffline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_party_CharOffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &party_id); + retVal___ = postHookFunc(retVal___, char_id, party_id); } } return retVal___; @@ -7368,11 +7360,11 @@ int HP_inter_pet_tosql(const struct s_pet *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_pet_tosql_pre ) { - int (*preHookFunc) (const struct s_pet *p); + int (*preHookFunc) (const struct s_pet **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_pet_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_pet_tosql_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7395,11 +7387,11 @@ int HP_inter_pet_fromsql(int pet_id, struct s_pet *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_pet_fromsql_pre ) { - int (*preHookFunc) (int *pet_id, struct s_pet *p); + int (*preHookFunc) (int *pet_id, struct s_pet **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_pet_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_pet_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&pet_id, p); + retVal___ = preHookFunc(&pet_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7410,10 +7402,10 @@ int HP_inter_pet_fromsql(int pet_id, struct s_pet *p) { retVal___ = HPMHooks.source.inter_pet.fromsql(pet_id, p); } if( HPMHooks.count.HP_inter_pet_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *pet_id, struct s_pet *p); + int (*postHookFunc) (int retVal___, int pet_id, struct s_pet *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_pet_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_pet_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pet_id, p); + retVal___ = postHookFunc(retVal___, pet_id, p); } } return retVal___; @@ -7490,10 +7482,10 @@ int HP_inter_pet_delete_(int pet_id) { retVal___ = HPMHooks.source.inter_pet.delete_(pet_id); } if( HPMHooks.count.HP_inter_pet_delete__post ) { - int (*postHookFunc) (int retVal___, int *pet_id); + int (*postHookFunc) (int retVal___, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_pet_delete__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_pet_delete__post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pet_id); + retVal___ = postHookFunc(retVal___, pet_id); } } return retVal___; @@ -7517,10 +7509,10 @@ int HP_inter_pet_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_pet.parse_frommap(fd); } if( HPMHooks.count.HP_inter_pet_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_pet_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_pet_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -7545,10 +7537,10 @@ int HP_inter_quest_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_quest.parse_frommap(fd); } if( HPMHooks.count.HP_inter_quest_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_quest_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_quest_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -7558,11 +7550,11 @@ int HP_inter_storage_tosql(int account_id, struct storage_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_storage_tosql_pre ) { - int (*preHookFunc) (int *account_id, struct storage_data *p); + int (*preHookFunc) (int *account_id, struct storage_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_storage_tosql_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, p); + retVal___ = preHookFunc(&account_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7573,10 +7565,10 @@ int HP_inter_storage_tosql(int account_id, struct storage_data *p) { retVal___ = HPMHooks.source.inter_storage.tosql(account_id, p); } if( HPMHooks.count.HP_inter_storage_tosql_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct storage_data *p); + int (*postHookFunc) (int retVal___, int account_id, struct storage_data *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, p); + retVal___ = postHookFunc(retVal___, account_id, p); } } return retVal___; @@ -7585,11 +7577,11 @@ int HP_inter_storage_fromsql(int account_id, struct storage_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_storage_fromsql_pre ) { - int (*preHookFunc) (int *account_id, struct storage_data *p); + int (*preHookFunc) (int *account_id, struct storage_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_storage_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, p); + retVal___ = preHookFunc(&account_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7600,10 +7592,10 @@ int HP_inter_storage_fromsql(int account_id, struct storage_data *p) { retVal___ = HPMHooks.source.inter_storage.fromsql(account_id, p); } if( HPMHooks.count.HP_inter_storage_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct storage_data *p); + int (*postHookFunc) (int retVal___, int account_id, struct storage_data *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, p); + retVal___ = postHookFunc(retVal___, account_id, p); } } return retVal___; @@ -7612,11 +7604,11 @@ int HP_inter_storage_guild_storage_tosql(int guild_id, const struct guild_storag int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_storage_guild_storage_tosql_pre ) { - int (*preHookFunc) (int *guild_id, const struct guild_storage *p); + int (*preHookFunc) (int *guild_id, const struct guild_storage **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_guild_storage_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_storage_guild_storage_tosql_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, p); + retVal___ = preHookFunc(&guild_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7627,10 +7619,10 @@ int HP_inter_storage_guild_storage_tosql(int guild_id, const struct guild_storag retVal___ = HPMHooks.source.inter_storage.guild_storage_tosql(guild_id, p); } if( HPMHooks.count.HP_inter_storage_guild_storage_tosql_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, const struct guild_storage *p); + int (*postHookFunc) (int retVal___, int guild_id, const struct guild_storage *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_guild_storage_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_guild_storage_tosql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, p); + retVal___ = postHookFunc(retVal___, guild_id, p); } } return retVal___; @@ -7639,11 +7631,11 @@ int HP_inter_storage_guild_storage_fromsql(int guild_id, struct guild_storage *p int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_inter_storage_guild_storage_fromsql_pre ) { - int (*preHookFunc) (int *guild_id, struct guild_storage *p); + int (*preHookFunc) (int *guild_id, struct guild_storage **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_guild_storage_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_inter_storage_guild_storage_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, p); + retVal___ = preHookFunc(&guild_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7654,10 +7646,10 @@ int HP_inter_storage_guild_storage_fromsql(int guild_id, struct guild_storage *p retVal___ = HPMHooks.source.inter_storage.guild_storage_fromsql(guild_id, p); } if( HPMHooks.count.HP_inter_storage_guild_storage_fromsql_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, struct guild_storage *p); + int (*postHookFunc) (int retVal___, int guild_id, struct guild_storage *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_guild_storage_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_guild_storage_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, p); + retVal___ = postHookFunc(retVal___, guild_id, p); } } return retVal___; @@ -7734,10 +7726,10 @@ int HP_inter_storage_delete_(int account_id) { retVal___ = HPMHooks.source.inter_storage.delete_(account_id); } if( HPMHooks.count.HP_inter_storage_delete__post ) { - int (*postHookFunc) (int retVal___, int *account_id); + int (*postHookFunc) (int retVal___, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_delete__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_delete__post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id); + retVal___ = postHookFunc(retVal___, account_id); } } return retVal___; @@ -7761,10 +7753,10 @@ int HP_inter_storage_guild_storage_delete(int guild_id) { retVal___ = HPMHooks.source.inter_storage.guild_storage_delete(guild_id); } if( HPMHooks.count.HP_inter_storage_guild_storage_delete_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_guild_storage_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_guild_storage_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -7788,10 +7780,10 @@ int HP_inter_storage_parse_frommap(int fd) { retVal___ = HPMHooks.source.inter_storage.parse_frommap(fd); } if( HPMHooks.count.HP_inter_storage_parse_frommap_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_inter_storage_parse_frommap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_inter_storage_parse_frommap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -7801,11 +7793,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_pre ) { - int (*preHookFunc) (struct config_t *config, FILE *stream); + int (*preHookFunc) (struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; - retVal___ = preHookFunc(config, stream); + retVal___ = preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7827,11 +7819,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { void HP_libconfig_write(const struct config_t *config, FILE *stream) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_write_pre ) { - void (*preHookFunc) (const struct config_t *config, FILE *stream); + void (*preHookFunc) (const struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; - preHookFunc(config, stream); + preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7853,11 +7845,11 @@ void HP_libconfig_write(const struct config_t *config, FILE *stream) { void HP_libconfig_set_options(struct config_t *config, int options) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_options_pre ) { - void (*preHookFunc) (struct config_t *config, int *options); + void (*preHookFunc) (struct config_t **config, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_options_pre[hIndex].func; - preHookFunc(config, &options); + preHookFunc(&config, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7868,10 +7860,10 @@ void HP_libconfig_set_options(struct config_t *config, int options) { HPMHooks.source.libconfig.set_options(config, options); } if( HPMHooks.count.HP_libconfig_set_options_post ) { - void (*postHookFunc) (struct config_t *config, int *options); + void (*postHookFunc) (struct config_t *config, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_set_options_post[hIndex].func; - postHookFunc(config, &options); + postHookFunc(config, options); } } return; @@ -7880,11 +7872,11 @@ int HP_libconfig_get_options(const struct config_t *config) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_get_options_pre ) { - int (*preHookFunc) (const struct config_t *config); + int (*preHookFunc) (const struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_get_options_pre[hIndex].func; - retVal___ = preHookFunc(config); + retVal___ = preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7907,11 +7899,11 @@ int HP_libconfig_read_string(struct config_t *config, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_string_pre ) { - int (*preHookFunc) (struct config_t *config, const char *str); + int (*preHookFunc) (struct config_t **config, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; - retVal___ = preHookFunc(config, str); + retVal___ = preHookFunc(&config, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7934,11 +7926,11 @@ int HP_libconfig_read_file_src(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7961,11 +7953,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_write_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7987,11 +7979,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) (void *)) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { - void (*preHookFunc) (struct config_t *config, void ( *destructor ) (void *)); + void (*preHookFunc) (struct config_t **config, void ( **destructor ) (void *)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; - preHookFunc(config, destructor); + preHookFunc(&config, &destructor); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8013,11 +8005,11 @@ void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) ( void HP_libconfig_set_include_dir(struct config_t *config, const char *include_dir) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { - void (*preHookFunc) (struct config_t *config, const char *include_dir); + void (*preHookFunc) (struct config_t **config, const char **include_dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; - preHookFunc(config, include_dir); + preHookFunc(&config, &include_dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8039,11 +8031,11 @@ void HP_libconfig_set_include_dir(struct config_t *config, const char *include_d void HP_libconfig_init(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_init_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8065,11 +8057,11 @@ void HP_libconfig_init(struct config_t *config) { void HP_libconfig_destroy(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_destroy_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8092,11 +8084,11 @@ int HP_libconfig_setting_get_int(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8119,11 +8111,11 @@ long long HP_libconfig_setting_get_int64(const struct config_setting_t *setting) int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting); + long long (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8146,11 +8138,11 @@ double HP_libconfig_setting_get_float(const struct config_setting_t *setting) { int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting); + double (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8173,11 +8165,11 @@ int HP_libconfig_setting_get_bool(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8200,11 +8192,11 @@ const char* HP_libconfig_setting_get_string(const struct config_setting_t *setti int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting); + const char* (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8227,11 +8219,11 @@ struct config_setting_t* HP_libconfig_setting_lookup(struct config_setting_t *se int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8254,11 +8246,11 @@ int HP_libconfig_setting_lookup_int(const struct config_setting_t *setting, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8281,11 +8273,11 @@ int HP_libconfig_setting_lookup_int64(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, long long *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8308,11 +8300,11 @@ int HP_libconfig_setting_lookup_float(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, double *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8335,11 +8327,11 @@ int HP_libconfig_setting_lookup_bool(const struct config_setting_t *setting, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8362,11 +8354,11 @@ int HP_libconfig_setting_lookup_string(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, const char **value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8389,11 +8381,11 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8404,10 +8396,10 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -8416,11 +8408,11 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, long long *value); + int (*preHookFunc) (struct config_setting_t **setting, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8431,10 +8423,10 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -8443,11 +8435,11 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, double *value); + int (*preHookFunc) (struct config_setting_t **setting, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8458,10 +8450,10 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -8470,11 +8462,11 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8485,10 +8477,10 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -8497,11 +8489,11 @@ int HP_libconfig_setting_set_string(struct config_setting_t *setting, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, const char *value); + int (*preHookFunc) (struct config_setting_t **setting, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8524,11 +8516,11 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, short *format); + int (*preHookFunc) (struct config_setting_t **setting, short *format); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; - retVal___ = preHookFunc(setting, &format); + retVal___ = preHookFunc(&setting, &format); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8539,10 +8531,10 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); } if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short *format); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short format); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &format); + retVal___ = postHookFunc(retVal___, setting, format); } } return retVal___; @@ -8551,11 +8543,11 @@ short HP_libconfig_setting_get_format(const struct config_setting_t *setting) { int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { - short (*preHookFunc) (const struct config_setting_t *setting); + short (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8578,11 +8570,11 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8593,10 +8585,10 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8605,11 +8597,11 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting, int *idx); + long long (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8620,10 +8612,10 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { - long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int *idx); + long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8632,11 +8624,11 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting, int *idx); + double (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8647,10 +8639,10 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { - double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int *idx); + double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8659,11 +8651,11 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8674,10 +8666,10 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8686,11 +8678,11 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting, int *idx); + const char* (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8701,10 +8693,10 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { - const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int *idx); + const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8713,11 +8705,11 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8728,10 +8720,10 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -8740,11 +8732,11 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8755,10 +8747,10 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -8767,11 +8759,11 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8782,10 +8774,10 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -8794,11 +8786,11 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8809,10 +8801,10 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -8821,11 +8813,11 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8836,10 +8828,10 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, const char *value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -8848,11 +8840,11 @@ int HP_libconfig_setting_index(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_index_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8875,11 +8867,11 @@ int HP_libconfig_setting_length(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_length_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8902,11 +8894,11 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8917,10 +8909,10 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -8929,11 +8921,11 @@ struct config_setting_t* HP_libconfig_setting_get_member(const struct config_set int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8956,11 +8948,11 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_add_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **parent, const char **name, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; - retVal___ = preHookFunc(parent, name, &type); + retVal___ = preHookFunc(&parent, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8971,10 +8963,10 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); } if( HPMHooks.count.HP_libconfig_setting_add_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, name, &type); + retVal___ = postHookFunc(retVal___, parent, name, type); } } return retVal___; @@ -8983,11 +8975,11 @@ int HP_libconfig_setting_remove(struct config_setting_t *parent, const char *nam int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const char *name); + int (*preHookFunc) (struct config_setting_t **parent, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; - retVal___ = preHookFunc(parent, name); + retVal___ = preHookFunc(&parent, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9010,11 +9002,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, unsigned int *idx); + int (*preHookFunc) (struct config_setting_t **parent, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; - retVal___ = preHookFunc(parent, &idx); + retVal___ = preHookFunc(&parent, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9025,10 +9017,10 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); } if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int *idx); + int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, &idx); + retVal___ = postHookFunc(retVal___, parent, idx); } } return retVal___; @@ -9036,11 +9028,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i void HP_libconfig_setting_set_hook(struct config_setting_t *setting, void *hook) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { - void (*preHookFunc) (struct config_setting_t *setting, void *hook); + void (*preHookFunc) (struct config_setting_t **setting, void **hook); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; - preHookFunc(setting, hook); + preHookFunc(&setting, &hook); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9063,11 +9055,11 @@ struct config_setting_t* HP_libconfig_lookup(const struct config_t *config, cons int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_t *config, const char *filepath); + struct config_setting_t* (*preHookFunc) (const struct config_t **config, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath); + retVal___ = preHookFunc(&config, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9090,11 +9082,11 @@ int HP_libconfig_lookup_int(const struct config_t *config, const char *filepath, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9117,11 +9109,11 @@ int HP_libconfig_lookup_int64(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, long long *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9144,11 +9136,11 @@ int HP_libconfig_lookup_float(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, double *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9171,11 +9163,11 @@ int HP_libconfig_lookup_bool(const struct config_t *config, const char *filepath int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9198,11 +9190,11 @@ int HP_libconfig_lookup_string(const struct config_t *config, const char *filepa int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, const char **value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9225,11 +9217,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_load_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *config_filename); + int (*preHookFunc) (struct config_t **config, const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_load_file_pre[hIndex].func; - retVal___ = preHookFunc(config, config_filename); + retVal___ = preHookFunc(&config, &config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9251,11 +9243,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9277,11 +9269,11 @@ void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const str void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9303,11 +9295,11 @@ void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struc void HP_libconfig_setting_copy_aggregate(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9330,11 +9322,11 @@ int HP_libconfig_setting_copy(struct config_setting_t *parent, const struct conf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + int (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; - retVal___ = preHookFunc(parent, src); + retVal___ = preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9357,11 +9349,11 @@ bool HP_libconfig_setting_get_bool_real(const struct config_setting_t *setting) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_libconfig_setting_get_bool_real_pre ) { - bool (*preHookFunc) (const struct config_setting_t *setting); + bool (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9384,11 +9376,11 @@ uint32 HP_libconfig_setting_get_uint32(const struct config_setting_t *setting) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint32_pre ) { - uint32 (*preHookFunc) (const struct config_setting_t *setting); + uint32 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9411,11 +9403,11 @@ uint16 HP_libconfig_setting_get_uint16(const struct config_setting_t *setting) { int hIndex = 0; uint16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint16_pre ) { - uint16 (*preHookFunc) (const struct config_setting_t *setting); + uint16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9438,11 +9430,11 @@ int16 HP_libconfig_setting_get_int16(const struct config_setting_t *setting) { int hIndex = 0; int16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int16_pre ) { - int16 (*preHookFunc) (const struct config_setting_t *setting); + int16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9465,11 +9457,11 @@ int HP_libconfig_setting_lookup_bool_real(const struct config_setting_t *setting int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, bool *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, bool **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9492,11 +9484,11 @@ int HP_libconfig_setting_lookup_uint32(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint32 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint32 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9519,11 +9511,11 @@ int HP_libconfig_setting_lookup_uint16(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9546,11 +9538,11 @@ int HP_libconfig_setting_lookup_int16(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9573,11 +9565,11 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, out, &out_size); + retVal___ = preHookFunc(&setting, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9588,10 +9580,10 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se retVal___ = HPMHooks.source.libconfig.setting_lookup_mutable_string(setting, name, out, out_size); } if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, name, out, &out_size); + retVal___ = postHookFunc(retVal___, setting, name, out, out_size); } } return retVal___; @@ -9600,11 +9592,11 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_t **config, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(config, name, out, &out_size); + retVal___ = preHookFunc(&config, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9615,10 +9607,10 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char retVal___ = HPMHooks.source.libconfig.lookup_mutable_string(config, name, out, out_size); } if( HPMHooks.count.HP_libconfig_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, config, name, out, &out_size); + retVal___ = postHookFunc(retVal___, config, name, out, out_size); } } return retVal___; @@ -9798,10 +9790,10 @@ void HP_loginif_block_account(int account_id, int flag) { HPMHooks.source.loginif.block_account(account_id, flag); } if( HPMHooks.count.HP_loginif_block_account_post ) { - void (*postHookFunc) (int *account_id, int *flag); + void (*postHookFunc) (int account_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_block_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_block_account_post[hIndex].func; - postHookFunc(&account_id, &flag); + postHookFunc(account_id, flag); } } return; @@ -9824,10 +9816,10 @@ void HP_loginif_ban_account(int account_id, short year, short month, short day, HPMHooks.source.loginif.ban_account(account_id, year, month, day, hour, minute, second); } if( HPMHooks.count.HP_loginif_ban_account_post ) { - void (*postHookFunc) (int *account_id, short *year, short *month, short *day, short *hour, short *minute, short *second); + void (*postHookFunc) (int account_id, short year, short month, short day, short hour, short minute, short second); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_ban_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_ban_account_post[hIndex].func; - postHookFunc(&account_id, &year, &month, &day, &hour, &minute, &second); + postHookFunc(account_id, year, month, day, hour, minute, second); } } return; @@ -9850,10 +9842,10 @@ void HP_loginif_unban_account(int account_id) { HPMHooks.source.loginif.unban_account(account_id); } if( HPMHooks.count.HP_loginif_unban_account_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_unban_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_unban_account_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -9876,10 +9868,10 @@ void HP_loginif_changesex(int account_id) { HPMHooks.source.loginif.changesex(account_id); } if( HPMHooks.count.HP_loginif_changesex_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_changesex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_changesex_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -9887,11 +9879,11 @@ void HP_loginif_changesex(int account_id) { void HP_loginif_auth(int fd, struct char_session_data *sd, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_loginif_auth_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*preHookFunc) (int *fd, struct char_session_data **sd, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_loginif_auth_pre[hIndex].func; - preHookFunc(&fd, sd, &ipl); + preHookFunc(&fd, &sd, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9902,10 +9894,10 @@ void HP_loginif_auth(int fd, struct char_session_data *sd, uint32 ipl) { HPMHooks.source.loginif.auth(fd, sd, ipl); } if( HPMHooks.count.HP_loginif_auth_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd, uint32 *ipl); + void (*postHookFunc) (int fd, struct char_session_data *sd, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_auth_post[hIndex].func; - postHookFunc(&fd, sd, &ipl); + postHookFunc(fd, sd, ipl); } } return; @@ -9928,10 +9920,10 @@ void HP_loginif_send_users_count(int users) { HPMHooks.source.loginif.send_users_count(users); } if( HPMHooks.count.HP_loginif_send_users_count_post ) { - void (*postHookFunc) (int *users); + void (*postHookFunc) (int users); for(hIndex = 0; hIndex < HPMHooks.count.HP_loginif_send_users_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_loginif_send_users_count_post[hIndex].func; - postHookFunc(&users); + postHookFunc(users); } } return; @@ -10019,11 +10011,11 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_malloc_pre ) { - void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; - retVal___ = preHookFunc(&size, file, &line, func); + retVal___ = preHookFunc(&size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10034,10 +10026,10 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); } if( HPMHooks.count.HP_iMalloc_malloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, size, file, line, func); } } return retVal___; @@ -10046,11 +10038,11 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_calloc_pre ) { - void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *num, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; - retVal___ = preHookFunc(&num, &size, file, &line, func); + retVal___ = preHookFunc(&num, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10061,10 +10053,10 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_calloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, num, size, file, line, func); } } return retVal___; @@ -10073,11 +10065,11 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_realloc_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10088,10 +10080,10 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_realloc_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -10100,11 +10092,11 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10115,10 +10107,10 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_reallocz_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -10127,11 +10119,11 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { - char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; - retVal___ = preHookFunc(p, file, &line, func); + retVal___ = preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10142,10 +10134,10 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrdup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, file, &line, func); + retVal___ = postHookFunc(retVal___, p, file, line, func); } } return retVal___; @@ -10154,11 +10146,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrndup_pre ) { - char* (*preHookFunc) (const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10169,10 +10161,10 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line retVal___ = HPMHooks.source.iMalloc.astrndup(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrndup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrndup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -10180,11 +10172,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { int hIndex = 0; if( HPMHooks.count.HP_iMalloc_free_pre ) { - void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + void (*preHookFunc) (void **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; - preHookFunc(p, file, &line, func); + preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10195,10 +10187,10 @@ void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { HPMHooks.source.iMalloc.free(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_free_post ) { - void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + void (*postHookFunc) (void *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; - postHookFunc(p, file, &line, func); + postHookFunc(p, file, line, func); } } return; @@ -10233,11 +10225,11 @@ bool HP_iMalloc_verify_ptr(void *ptr) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { - bool (*preHookFunc) (void *ptr); + bool (*preHookFunc) (void **ptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; - retVal___ = preHookFunc(ptr); + retVal___ = preHookFunc(&ptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10354,10 +10346,10 @@ void HP_mapif_ban(int id, unsigned int flag, int status) { HPMHooks.source.mapif.ban(id, flag, status); } if( HPMHooks.count.HP_mapif_ban_post ) { - void (*postHookFunc) (int *id, unsigned int *flag, int *status); + void (*postHookFunc) (int id, unsigned int flag, int status); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_ban_post[hIndex].func; - postHookFunc(&id, &flag, &status); + postHookFunc(id, flag, status); } } return; @@ -10380,10 +10372,10 @@ void HP_mapif_server_init(int id) { HPMHooks.source.mapif.server_init(id); } if( HPMHooks.count.HP_mapif_server_init_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_server_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_server_init_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -10406,10 +10398,10 @@ void HP_mapif_server_destroy(int id) { HPMHooks.source.mapif.server_destroy(id); } if( HPMHooks.count.HP_mapif_server_destroy_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_server_destroy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_server_destroy_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -10432,10 +10424,10 @@ void HP_mapif_server_reset(int id) { HPMHooks.source.mapif.server_reset(id); } if( HPMHooks.count.HP_mapif_server_reset_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_server_reset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_server_reset_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -10458,10 +10450,10 @@ void HP_mapif_on_disconnect(int id) { HPMHooks.source.mapif.on_disconnect(id); } if( HPMHooks.count.HP_mapif_on_disconnect_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_on_disconnect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_on_disconnect_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -10484,10 +10476,10 @@ void HP_mapif_on_parse_accinfo(int account_id, int u_fd, int u_aid, int u_group, HPMHooks.source.mapif.on_parse_accinfo(account_id, u_fd, u_aid, u_group, map_fd); } if( HPMHooks.count.HP_mapif_on_parse_accinfo_post ) { - void (*postHookFunc) (int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd); + void (*postHookFunc) (int account_id, int u_fd, int u_aid, int u_group, int map_fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_on_parse_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_on_parse_accinfo_post[hIndex].func; - postHookFunc(&account_id, &u_fd, &u_aid, &u_group, &map_fd); + postHookFunc(account_id, u_fd, u_aid, u_group, map_fd); } } return; @@ -10510,10 +10502,10 @@ void HP_mapif_char_ban(int char_id, time_t timestamp) { HPMHooks.source.mapif.char_ban(char_id, timestamp); } if( HPMHooks.count.HP_mapif_char_ban_post ) { - void (*postHookFunc) (int *char_id, time_t *timestamp); + void (*postHookFunc) (int char_id, time_t timestamp); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_char_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_char_ban_post[hIndex].func; - postHookFunc(&char_id, ×tamp); + postHookFunc(char_id, timestamp); } } return; @@ -10522,11 +10514,11 @@ int HP_mapif_sendall(const unsigned char *buf, unsigned int len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_sendall_pre ) { - int (*preHookFunc) (const unsigned char *buf, unsigned int *len); + int (*preHookFunc) (const unsigned char **buf, unsigned int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_sendall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_sendall_pre[hIndex].func; - retVal___ = preHookFunc(buf, &len); + retVal___ = preHookFunc(&buf, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10537,10 +10529,10 @@ int HP_mapif_sendall(const unsigned char *buf, unsigned int len) { retVal___ = HPMHooks.source.mapif.sendall(buf, len); } if( HPMHooks.count.HP_mapif_sendall_post ) { - int (*postHookFunc) (int retVal___, const unsigned char *buf, unsigned int *len); + int (*postHookFunc) (int retVal___, const unsigned char *buf, unsigned int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_sendall_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_sendall_post[hIndex].func; - retVal___ = postHookFunc(retVal___, buf, &len); + retVal___ = postHookFunc(retVal___, buf, len); } } return retVal___; @@ -10549,11 +10541,11 @@ int HP_mapif_sendallwos(int sfd, unsigned char *buf, unsigned int len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_sendallwos_pre ) { - int (*preHookFunc) (int *sfd, unsigned char *buf, unsigned int *len); + int (*preHookFunc) (int *sfd, unsigned char **buf, unsigned int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_sendallwos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_sendallwos_pre[hIndex].func; - retVal___ = preHookFunc(&sfd, buf, &len); + retVal___ = preHookFunc(&sfd, &buf, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10564,10 +10556,10 @@ int HP_mapif_sendallwos(int sfd, unsigned char *buf, unsigned int len) { retVal___ = HPMHooks.source.mapif.sendallwos(sfd, buf, len); } if( HPMHooks.count.HP_mapif_sendallwos_post ) { - int (*postHookFunc) (int retVal___, int *sfd, unsigned char *buf, unsigned int *len); + int (*postHookFunc) (int retVal___, int sfd, unsigned char *buf, unsigned int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_sendallwos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_sendallwos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &sfd, buf, &len); + retVal___ = postHookFunc(retVal___, sfd, buf, len); } } return retVal___; @@ -10576,11 +10568,11 @@ int HP_mapif_send(int fd, unsigned char *buf, unsigned int len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_send_pre ) { - int (*preHookFunc) (int *fd, unsigned char *buf, unsigned int *len); + int (*preHookFunc) (int *fd, unsigned char **buf, unsigned int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_send_pre[hIndex].func; - retVal___ = preHookFunc(&fd, buf, &len); + retVal___ = preHookFunc(&fd, &buf, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10591,10 +10583,10 @@ int HP_mapif_send(int fd, unsigned char *buf, unsigned int len) { retVal___ = HPMHooks.source.mapif.send(fd, buf, len); } if( HPMHooks.count.HP_mapif_send_post ) { - int (*postHookFunc) (int retVal___, int *fd, unsigned char *buf, unsigned int *len); + int (*postHookFunc) (int retVal___, int fd, unsigned char *buf, unsigned int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_send_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, buf, &len); + retVal___ = postHookFunc(retVal___, fd, buf, len); } } return retVal___; @@ -10617,10 +10609,10 @@ void HP_mapif_send_users_count(int users) { HPMHooks.source.mapif.send_users_count(users); } if( HPMHooks.count.HP_mapif_send_users_count_post ) { - void (*postHookFunc) (int *users); + void (*postHookFunc) (int users); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_send_users_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_send_users_count_post[hIndex].func; - postHookFunc(&users); + postHookFunc(users); } } return; @@ -10643,10 +10635,10 @@ void HP_mapif_auction_message(int char_id, unsigned char result) { HPMHooks.source.mapif.auction_message(char_id, result); } if( HPMHooks.count.HP_mapif_auction_message_post ) { - void (*postHookFunc) (int *char_id, unsigned char *result); + void (*postHookFunc) (int char_id, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_message_post[hIndex].func; - postHookFunc(&char_id, &result); + postHookFunc(char_id, result); } } return; @@ -10654,11 +10646,11 @@ void HP_mapif_auction_message(int char_id, unsigned char result) { void HP_mapif_auction_sendlist(int fd, int char_id, short count, short pages, unsigned char *buf) { int hIndex = 0; if( HPMHooks.count.HP_mapif_auction_sendlist_pre ) { - void (*preHookFunc) (int *fd, int *char_id, short *count, short *pages, unsigned char *buf); + void (*preHookFunc) (int *fd, int *char_id, short *count, short *pages, unsigned char **buf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_sendlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_auction_sendlist_pre[hIndex].func; - preHookFunc(&fd, &char_id, &count, &pages, buf); + preHookFunc(&fd, &char_id, &count, &pages, &buf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10669,10 +10661,10 @@ void HP_mapif_auction_sendlist(int fd, int char_id, short count, short pages, un HPMHooks.source.mapif.auction_sendlist(fd, char_id, count, pages, buf); } if( HPMHooks.count.HP_mapif_auction_sendlist_post ) { - void (*postHookFunc) (int *fd, int *char_id, short *count, short *pages, unsigned char *buf); + void (*postHookFunc) (int fd, int char_id, short count, short pages, unsigned char *buf); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_sendlist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_sendlist_post[hIndex].func; - postHookFunc(&fd, &char_id, &count, &pages, buf); + postHookFunc(fd, char_id, count, pages, buf); } } return; @@ -10695,10 +10687,10 @@ void HP_mapif_parse_auction_requestlist(int fd) { HPMHooks.source.mapif.parse_auction_requestlist(fd); } if( HPMHooks.count.HP_mapif_parse_auction_requestlist_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_auction_requestlist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_auction_requestlist_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -10706,11 +10698,11 @@ void HP_mapif_parse_auction_requestlist(int fd) { void HP_mapif_auction_register(int fd, struct auction_data *auction) { int hIndex = 0; if( HPMHooks.count.HP_mapif_auction_register_pre ) { - void (*preHookFunc) (int *fd, struct auction_data *auction); + void (*preHookFunc) (int *fd, struct auction_data **auction); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_register_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_auction_register_pre[hIndex].func; - preHookFunc(&fd, auction); + preHookFunc(&fd, &auction); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10721,10 +10713,10 @@ void HP_mapif_auction_register(int fd, struct auction_data *auction) { HPMHooks.source.mapif.auction_register(fd, auction); } if( HPMHooks.count.HP_mapif_auction_register_post ) { - void (*postHookFunc) (int *fd, struct auction_data *auction); + void (*postHookFunc) (int fd, struct auction_data *auction); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_register_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_register_post[hIndex].func; - postHookFunc(&fd, auction); + postHookFunc(fd, auction); } } return; @@ -10747,10 +10739,10 @@ void HP_mapif_parse_auction_register(int fd) { HPMHooks.source.mapif.parse_auction_register(fd); } if( HPMHooks.count.HP_mapif_parse_auction_register_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_auction_register_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_auction_register_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -10773,10 +10765,10 @@ void HP_mapif_auction_cancel(int fd, int char_id, unsigned char result) { HPMHooks.source.mapif.auction_cancel(fd, char_id, result); } if( HPMHooks.count.HP_mapif_auction_cancel_post ) { - void (*postHookFunc) (int *fd, int *char_id, unsigned char *result); + void (*postHookFunc) (int fd, int char_id, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_cancel_post[hIndex].func; - postHookFunc(&fd, &char_id, &result); + postHookFunc(fd, char_id, result); } } return; @@ -10799,10 +10791,10 @@ void HP_mapif_parse_auction_cancel(int fd) { HPMHooks.source.mapif.parse_auction_cancel(fd); } if( HPMHooks.count.HP_mapif_parse_auction_cancel_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_auction_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_auction_cancel_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -10825,10 +10817,10 @@ void HP_mapif_auction_close(int fd, int char_id, unsigned char result) { HPMHooks.source.mapif.auction_close(fd, char_id, result); } if( HPMHooks.count.HP_mapif_auction_close_post ) { - void (*postHookFunc) (int *fd, int *char_id, unsigned char *result); + void (*postHookFunc) (int fd, int char_id, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_close_post[hIndex].func; - postHookFunc(&fd, &char_id, &result); + postHookFunc(fd, char_id, result); } } return; @@ -10851,10 +10843,10 @@ void HP_mapif_parse_auction_close(int fd) { HPMHooks.source.mapif.parse_auction_close(fd); } if( HPMHooks.count.HP_mapif_parse_auction_close_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_auction_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_auction_close_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -10877,10 +10869,10 @@ void HP_mapif_auction_bid(int fd, int char_id, int bid, unsigned char result) { HPMHooks.source.mapif.auction_bid(fd, char_id, bid, result); } if( HPMHooks.count.HP_mapif_auction_bid_post ) { - void (*postHookFunc) (int *fd, int *char_id, int *bid, unsigned char *result); + void (*postHookFunc) (int fd, int char_id, int bid, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_auction_bid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_auction_bid_post[hIndex].func; - postHookFunc(&fd, &char_id, &bid, &result); + postHookFunc(fd, char_id, bid, result); } } return; @@ -10903,10 +10895,10 @@ void HP_mapif_parse_auction_bid(int fd) { HPMHooks.source.mapif.parse_auction_bid(fd); } if( HPMHooks.count.HP_mapif_parse_auction_bid_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_auction_bid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_auction_bid_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -10915,11 +10907,11 @@ bool HP_mapif_elemental_create(struct s_elemental *ele) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_elemental_create_pre ) { - bool (*preHookFunc) (struct s_elemental *ele); + bool (*preHookFunc) (struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_elemental_create_pre[hIndex].func; - retVal___ = preHookFunc(ele); + retVal___ = preHookFunc(&ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10942,11 +10934,11 @@ bool HP_mapif_elemental_save(const struct s_elemental *ele) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_elemental_save_pre ) { - bool (*preHookFunc) (const struct s_elemental *ele); + bool (*preHookFunc) (const struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_elemental_save_pre[hIndex].func; - retVal___ = preHookFunc(ele); + retVal___ = preHookFunc(&ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10969,11 +10961,11 @@ bool HP_mapif_elemental_load(int ele_id, int char_id, struct s_elemental *ele) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_elemental_load_pre ) { - bool (*preHookFunc) (int *ele_id, int *char_id, struct s_elemental *ele); + bool (*preHookFunc) (int *ele_id, int *char_id, struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_elemental_load_pre[hIndex].func; - retVal___ = preHookFunc(&ele_id, &char_id, ele); + retVal___ = preHookFunc(&ele_id, &char_id, &ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10984,10 +10976,10 @@ bool HP_mapif_elemental_load(int ele_id, int char_id, struct s_elemental *ele) { retVal___ = HPMHooks.source.mapif.elemental_load(ele_id, char_id, ele); } if( HPMHooks.count.HP_mapif_elemental_load_post ) { - bool (*postHookFunc) (bool retVal___, int *ele_id, int *char_id, struct s_elemental *ele); + bool (*postHookFunc) (bool retVal___, int ele_id, int char_id, struct s_elemental *ele); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_elemental_load_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ele_id, &char_id, ele); + retVal___ = postHookFunc(retVal___, ele_id, char_id, ele); } } return retVal___; @@ -11011,10 +11003,10 @@ bool HP_mapif_elemental_delete(int ele_id) { retVal___ = HPMHooks.source.mapif.elemental_delete(ele_id); } if( HPMHooks.count.HP_mapif_elemental_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *ele_id); + bool (*postHookFunc) (bool retVal___, int ele_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_elemental_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ele_id); + retVal___ = postHookFunc(retVal___, ele_id); } } return retVal___; @@ -11022,11 +11014,11 @@ bool HP_mapif_elemental_delete(int ele_id) { void HP_mapif_elemental_send(int fd, struct s_elemental *ele, unsigned char flag) { int hIndex = 0; if( HPMHooks.count.HP_mapif_elemental_send_pre ) { - void (*preHookFunc) (int *fd, struct s_elemental *ele, unsigned char *flag); + void (*preHookFunc) (int *fd, struct s_elemental **ele, unsigned char *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_elemental_send_pre[hIndex].func; - preHookFunc(&fd, ele, &flag); + preHookFunc(&fd, &ele, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11037,10 +11029,10 @@ void HP_mapif_elemental_send(int fd, struct s_elemental *ele, unsigned char flag HPMHooks.source.mapif.elemental_send(fd, ele, flag); } if( HPMHooks.count.HP_mapif_elemental_send_post ) { - void (*postHookFunc) (int *fd, struct s_elemental *ele, unsigned char *flag); + void (*postHookFunc) (int fd, struct s_elemental *ele, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_elemental_send_post[hIndex].func; - postHookFunc(&fd, ele, &flag); + postHookFunc(fd, ele, flag); } } return; @@ -11048,11 +11040,11 @@ void HP_mapif_elemental_send(int fd, struct s_elemental *ele, unsigned char flag void HP_mapif_parse_elemental_create(int fd, const struct s_elemental *ele) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_elemental_create_pre ) { - void (*preHookFunc) (int *fd, const struct s_elemental *ele); + void (*preHookFunc) (int *fd, const struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_elemental_create_pre[hIndex].func; - preHookFunc(&fd, ele); + preHookFunc(&fd, &ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11063,10 +11055,10 @@ void HP_mapif_parse_elemental_create(int fd, const struct s_elemental *ele) { HPMHooks.source.mapif.parse_elemental_create(fd, ele); } if( HPMHooks.count.HP_mapif_parse_elemental_create_post ) { - void (*postHookFunc) (int *fd, const struct s_elemental *ele); + void (*postHookFunc) (int fd, const struct s_elemental *ele); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_elemental_create_post[hIndex].func; - postHookFunc(&fd, ele); + postHookFunc(fd, ele); } } return; @@ -11089,10 +11081,10 @@ void HP_mapif_parse_elemental_load(int fd, int ele_id, int char_id) { HPMHooks.source.mapif.parse_elemental_load(fd, ele_id, char_id); } if( HPMHooks.count.HP_mapif_parse_elemental_load_post ) { - void (*postHookFunc) (int *fd, int *ele_id, int *char_id); + void (*postHookFunc) (int fd, int ele_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_elemental_load_post[hIndex].func; - postHookFunc(&fd, &ele_id, &char_id); + postHookFunc(fd, ele_id, char_id); } } return; @@ -11115,10 +11107,10 @@ void HP_mapif_elemental_deleted(int fd, unsigned char flag) { HPMHooks.source.mapif.elemental_deleted(fd, flag); } if( HPMHooks.count.HP_mapif_elemental_deleted_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_deleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_elemental_deleted_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -11141,10 +11133,10 @@ void HP_mapif_parse_elemental_delete(int fd, int ele_id) { HPMHooks.source.mapif.parse_elemental_delete(fd, ele_id); } if( HPMHooks.count.HP_mapif_parse_elemental_delete_post ) { - void (*postHookFunc) (int *fd, int *ele_id); + void (*postHookFunc) (int fd, int ele_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_elemental_delete_post[hIndex].func; - postHookFunc(&fd, &ele_id); + postHookFunc(fd, ele_id); } } return; @@ -11167,10 +11159,10 @@ void HP_mapif_elemental_saved(int fd, unsigned char flag) { HPMHooks.source.mapif.elemental_saved(fd, flag); } if( HPMHooks.count.HP_mapif_elemental_saved_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_elemental_saved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_elemental_saved_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -11178,11 +11170,11 @@ void HP_mapif_elemental_saved(int fd, unsigned char flag) { void HP_mapif_parse_elemental_save(int fd, const struct s_elemental *ele) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_elemental_save_pre ) { - void (*preHookFunc) (int *fd, const struct s_elemental *ele); + void (*preHookFunc) (int *fd, const struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_elemental_save_pre[hIndex].func; - preHookFunc(&fd, ele); + preHookFunc(&fd, &ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11193,10 +11185,10 @@ void HP_mapif_parse_elemental_save(int fd, const struct s_elemental *ele) { HPMHooks.source.mapif.parse_elemental_save(fd, ele); } if( HPMHooks.count.HP_mapif_parse_elemental_save_post ) { - void (*postHookFunc) (int *fd, const struct s_elemental *ele); + void (*postHookFunc) (int fd, const struct s_elemental *ele); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_elemental_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_elemental_save_post[hIndex].func; - postHookFunc(&fd, ele); + postHookFunc(fd, ele); } } return; @@ -11205,11 +11197,11 @@ int HP_mapif_guild_created(int fd, int account_id, struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_created_pre ) { - int (*preHookFunc) (int *fd, int *account_id, struct guild *g); + int (*preHookFunc) (int *fd, int *account_id, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_created_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, g); + retVal___ = preHookFunc(&fd, &account_id, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11220,10 +11212,10 @@ int HP_mapif_guild_created(int fd, int account_id, struct guild *g) { retVal___ = HPMHooks.source.mapif.guild_created(fd, account_id, g); } if( HPMHooks.count.HP_mapif_guild_created_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, struct guild *g); + int (*postHookFunc) (int retVal___, int fd, int account_id, struct guild *g); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_created_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, g); + retVal___ = postHookFunc(retVal___, fd, account_id, g); } } return retVal___; @@ -11247,10 +11239,10 @@ int HP_mapif_guild_noinfo(int fd, int guild_id) { retVal___ = HPMHooks.source.mapif.guild_noinfo(fd, guild_id); } if( HPMHooks.count.HP_mapif_guild_noinfo_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id); + int (*postHookFunc) (int retVal___, int fd, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_noinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_noinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id); + retVal___ = postHookFunc(retVal___, fd, guild_id); } } return retVal___; @@ -11259,11 +11251,11 @@ int HP_mapif_guild_info(int fd, struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_info_pre ) { - int (*preHookFunc) (int *fd, struct guild *g); + int (*preHookFunc) (int *fd, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_info_pre[hIndex].func; - retVal___ = preHookFunc(&fd, g); + retVal___ = preHookFunc(&fd, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11274,10 +11266,10 @@ int HP_mapif_guild_info(int fd, struct guild *g) { retVal___ = HPMHooks.source.mapif.guild_info(fd, g); } if( HPMHooks.count.HP_mapif_guild_info_post ) { - int (*postHookFunc) (int retVal___, int *fd, struct guild *g); + int (*postHookFunc) (int retVal___, int fd, struct guild *g); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, g); + retVal___ = postHookFunc(retVal___, fd, g); } } return retVal___; @@ -11301,10 +11293,10 @@ int HP_mapif_guild_memberadded(int fd, int guild_id, int account_id, int char_id retVal___ = HPMHooks.source.mapif.guild_memberadded(fd, guild_id, account_id, char_id, flag); } if( HPMHooks.count.HP_mapif_guild_memberadded_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *account_id, int *char_id, int *flag); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int account_id, int char_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_memberadded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_memberadded_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &account_id, &char_id, &flag); + retVal___ = postHookFunc(retVal___, fd, guild_id, account_id, char_id, flag); } } return retVal___; @@ -11313,11 +11305,11 @@ int HP_mapif_guild_withdraw(int guild_id, int account_id, int char_id, int flag, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_withdraw_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char **name, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_withdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_withdraw_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, name, mes); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, &name, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11328,10 +11320,10 @@ int HP_mapif_guild_withdraw(int guild_id, int account_id, int char_id, int flag, retVal___ = HPMHooks.source.mapif.guild_withdraw(guild_id, account_id, char_id, flag, name, mes); } if( HPMHooks.count.HP_mapif_guild_withdraw_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_withdraw_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag, name, mes); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag, name, mes); } } return retVal___; @@ -11340,11 +11332,11 @@ int HP_mapif_guild_memberinfoshort(struct guild *g, int idx) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_memberinfoshort_pre ) { - int (*preHookFunc) (struct guild *g, int *idx); + int (*preHookFunc) (struct guild **g, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_memberinfoshort_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_memberinfoshort_pre[hIndex].func; - retVal___ = preHookFunc(g, &idx); + retVal___ = preHookFunc(&g, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11355,10 +11347,10 @@ int HP_mapif_guild_memberinfoshort(struct guild *g, int idx) { retVal___ = HPMHooks.source.mapif.guild_memberinfoshort(g, idx); } if( HPMHooks.count.HP_mapif_guild_memberinfoshort_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *idx); + int (*postHookFunc) (int retVal___, struct guild *g, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_memberinfoshort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_memberinfoshort_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &idx); + retVal___ = postHookFunc(retVal___, g, idx); } } return retVal___; @@ -11382,10 +11374,10 @@ int HP_mapif_guild_broken(int guild_id, int flag) { retVal___ = HPMHooks.source.mapif.guild_broken(guild_id, flag); } if( HPMHooks.count.HP_mapif_guild_broken_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *flag); + int (*postHookFunc) (int retVal___, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_broken_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, guild_id, flag); } } return retVal___; @@ -11394,11 +11386,11 @@ int HP_mapif_guild_message(int guild_id, int account_id, const char *mes, int le int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_message_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len, int *sfd); + int (*preHookFunc) (int *guild_id, int *account_id, const char **mes, int *len, int *sfd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_message_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, mes, &len, &sfd); + retVal___ = preHookFunc(&guild_id, &account_id, &mes, &len, &sfd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11409,10 +11401,10 @@ int HP_mapif_guild_message(int guild_id, int account_id, const char *mes, int le retVal___ = HPMHooks.source.mapif.guild_message(guild_id, account_id, mes, len, sfd); } if( HPMHooks.count.HP_mapif_guild_message_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, const char *mes, int *len, int *sfd); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, const char *mes, int len, int sfd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, mes, &len, &sfd); + retVal___ = postHookFunc(retVal___, guild_id, account_id, mes, len, sfd); } } return retVal___; @@ -11421,11 +11413,11 @@ int HP_mapif_guild_basicinfochanged(int guild_id, int type, const void *data, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_basicinfochanged_pre ) { - int (*preHookFunc) (int *guild_id, int *type, const void *data, int *len); + int (*preHookFunc) (int *guild_id, int *type, const void **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_basicinfochanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_basicinfochanged_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &type, data, &len); + retVal___ = preHookFunc(&guild_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11436,10 +11428,10 @@ int HP_mapif_guild_basicinfochanged(int guild_id, int type, const void *data, in retVal___ = HPMHooks.source.mapif.guild_basicinfochanged(guild_id, type, data, len); } if( HPMHooks.count.HP_mapif_guild_basicinfochanged_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *type, const void *data, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int type, const void *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_basicinfochanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_basicinfochanged_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, guild_id, type, data, len); } } return retVal___; @@ -11448,11 +11440,11 @@ int HP_mapif_guild_memberinfochanged(int guild_id, int account_id, int char_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_memberinfochanged_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *type, const void **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_memberinfochanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_memberinfochanged_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11463,10 +11455,10 @@ int HP_mapif_guild_memberinfochanged(int guild_id, int account_id, int char_id, retVal___ = HPMHooks.source.mapif.guild_memberinfochanged(guild_id, account_id, char_id, type, data, len); } if( HPMHooks.count.HP_mapif_guild_memberinfochanged_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int type, const void *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_memberinfochanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_memberinfochanged_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, type, data, len); } } return retVal___; @@ -11490,10 +11482,10 @@ int HP_mapif_guild_skillupack(int guild_id, uint16 skill_id, int account_id) { retVal___ = HPMHooks.source.mapif.guild_skillupack(guild_id, skill_id, account_id); } if( HPMHooks.count.HP_mapif_guild_skillupack_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, uint16 *skill_id, int *account_id); + int (*postHookFunc) (int retVal___, int guild_id, uint16 skill_id, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_skillupack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_skillupack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &skill_id, &account_id); + retVal___ = postHookFunc(retVal___, guild_id, skill_id, account_id); } } return retVal___; @@ -11502,11 +11494,11 @@ int HP_mapif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int a int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_alliance_pre ) { - int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2); + int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char **name1, const char **name2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_alliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_alliance_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2); + retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag, &name1, &name2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11517,10 +11509,10 @@ int HP_mapif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int a retVal___ = HPMHooks.source.mapif.guild_alliance(guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2); } if( HPMHooks.count.HP_mapif_guild_alliance_post ) { - int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2); + int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_alliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_alliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2); + retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2); } } return retVal___; @@ -11529,11 +11521,11 @@ int HP_mapif_guild_position(struct guild *g, int idx) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_position_pre ) { - int (*preHookFunc) (struct guild *g, int *idx); + int (*preHookFunc) (struct guild **g, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_position_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_position_pre[hIndex].func; - retVal___ = preHookFunc(g, &idx); + retVal___ = preHookFunc(&g, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11544,10 +11536,10 @@ int HP_mapif_guild_position(struct guild *g, int idx) { retVal___ = HPMHooks.source.mapif.guild_position(g, idx); } if( HPMHooks.count.HP_mapif_guild_position_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *idx); + int (*postHookFunc) (int retVal___, struct guild *g, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_position_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_position_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &idx); + retVal___ = postHookFunc(retVal___, g, idx); } } return retVal___; @@ -11556,11 +11548,11 @@ int HP_mapif_guild_notice(struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_notice_pre ) { - int (*preHookFunc) (struct guild *g); + int (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_notice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_notice_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11583,11 +11575,11 @@ int HP_mapif_guild_emblem(struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_emblem_pre ) { - int (*preHookFunc) (struct guild *g); + int (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_emblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_emblem_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11610,11 +11602,11 @@ int HP_mapif_guild_master_changed(struct guild *g, int aid, int cid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_master_changed_pre ) { - int (*preHookFunc) (struct guild *g, int *aid, int *cid); + int (*preHookFunc) (struct guild **g, int *aid, int *cid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_master_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_master_changed_pre[hIndex].func; - retVal___ = preHookFunc(g, &aid, &cid); + retVal___ = preHookFunc(&g, &aid, &cid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11625,10 +11617,10 @@ int HP_mapif_guild_master_changed(struct guild *g, int aid, int cid) { retVal___ = HPMHooks.source.mapif.guild_master_changed(g, aid, cid); } if( HPMHooks.count.HP_mapif_guild_master_changed_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *aid, int *cid); + int (*postHookFunc) (int retVal___, struct guild *g, int aid, int cid); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_master_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_master_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &aid, &cid); + retVal___ = postHookFunc(retVal___, g, aid, cid); } } return retVal___; @@ -11637,11 +11629,11 @@ int HP_mapif_guild_castle_dataload(int fd, int sz, const int *castle_ids) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_guild_castle_dataload_pre ) { - int (*preHookFunc) (int *fd, int *sz, const int *castle_ids); + int (*preHookFunc) (int *fd, int *sz, const int **castle_ids); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_castle_dataload_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_guild_castle_dataload_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &sz, castle_ids); + retVal___ = preHookFunc(&fd, &sz, &castle_ids); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11652,10 +11644,10 @@ int HP_mapif_guild_castle_dataload(int fd, int sz, const int *castle_ids) { retVal___ = HPMHooks.source.mapif.guild_castle_dataload(fd, sz, castle_ids); } if( HPMHooks.count.HP_mapif_guild_castle_dataload_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *sz, const int *castle_ids); + int (*postHookFunc) (int retVal___, int fd, int sz, const int *castle_ids); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_guild_castle_dataload_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_guild_castle_dataload_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &sz, castle_ids); + retVal___ = postHookFunc(retVal___, fd, sz, castle_ids); } } return retVal___; @@ -11664,11 +11656,11 @@ int HP_mapif_parse_CreateGuild(int fd, int account_id, const char *name, const s int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_CreateGuild_pre ) { - int (*preHookFunc) (int *fd, int *account_id, const char *name, const struct guild_member *master); + int (*preHookFunc) (int *fd, int *account_id, const char **name, const struct guild_member **master); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_CreateGuild_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_CreateGuild_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, name, master); + retVal___ = preHookFunc(&fd, &account_id, &name, &master); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11679,10 +11671,10 @@ int HP_mapif_parse_CreateGuild(int fd, int account_id, const char *name, const s retVal___ = HPMHooks.source.mapif.parse_CreateGuild(fd, account_id, name, master); } if( HPMHooks.count.HP_mapif_parse_CreateGuild_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, const char *name, const struct guild_member *master); + int (*postHookFunc) (int retVal___, int fd, int account_id, const char *name, const struct guild_member *master); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_CreateGuild_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_CreateGuild_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, name, master); + retVal___ = postHookFunc(retVal___, fd, account_id, name, master); } } return retVal___; @@ -11706,10 +11698,10 @@ int HP_mapif_parse_GuildInfo(int fd, int guild_id) { retVal___ = HPMHooks.source.mapif.parse_GuildInfo(fd, guild_id); } if( HPMHooks.count.HP_mapif_parse_GuildInfo_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id); + int (*postHookFunc) (int retVal___, int fd, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildInfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id); + retVal___ = postHookFunc(retVal___, fd, guild_id); } } return retVal___; @@ -11718,11 +11710,11 @@ int HP_mapif_parse_GuildAddMember(int fd, int guild_id, const struct guild_membe int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildAddMember_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, const struct guild_member *m); + int (*preHookFunc) (int *fd, int *guild_id, const struct guild_member **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildAddMember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildAddMember_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, m); + retVal___ = preHookFunc(&fd, &guild_id, &m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11733,10 +11725,10 @@ int HP_mapif_parse_GuildAddMember(int fd, int guild_id, const struct guild_membe retVal___ = HPMHooks.source.mapif.parse_GuildAddMember(fd, guild_id, m); } if( HPMHooks.count.HP_mapif_parse_GuildAddMember_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, const struct guild_member *m); + int (*postHookFunc) (int retVal___, int fd, int guild_id, const struct guild_member *m); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildAddMember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildAddMember_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, m); + retVal___ = postHookFunc(retVal___, fd, guild_id, m); } } return retVal___; @@ -11745,11 +11737,11 @@ int HP_mapif_parse_GuildLeave(int fd, int guild_id, int account_id, int char_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildLeave_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, int *account_id, int *char_id, int *flag, const char *mes); + int (*preHookFunc) (int *fd, int *guild_id, int *account_id, int *char_id, int *flag, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildLeave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildLeave_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, &account_id, &char_id, &flag, mes); + retVal___ = preHookFunc(&fd, &guild_id, &account_id, &char_id, &flag, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11760,10 +11752,10 @@ int HP_mapif_parse_GuildLeave(int fd, int guild_id, int account_id, int char_id, retVal___ = HPMHooks.source.mapif.parse_GuildLeave(fd, guild_id, account_id, char_id, flag, mes); } if( HPMHooks.count.HP_mapif_parse_GuildLeave_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *account_id, int *char_id, int *flag, const char *mes); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int account_id, int char_id, int flag, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildLeave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildLeave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &account_id, &char_id, &flag, mes); + retVal___ = postHookFunc(retVal___, fd, guild_id, account_id, char_id, flag, mes); } } return retVal___; @@ -11787,10 +11779,10 @@ int HP_mapif_parse_GuildChangeMemberInfoShort(int fd, int guild_id, int account_ retVal___ = HPMHooks.source.mapif.parse_GuildChangeMemberInfoShort(fd, guild_id, account_id, char_id, online, lv, class_); } if( HPMHooks.count.HP_mapif_parse_GuildChangeMemberInfoShort_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int account_id, int char_id, int online, int lv, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildChangeMemberInfoShort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildChangeMemberInfoShort_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &account_id, &char_id, &online, &lv, &class_); + retVal___ = postHookFunc(retVal___, fd, guild_id, account_id, char_id, online, lv, class_); } } return retVal___; @@ -11814,10 +11806,10 @@ int HP_mapif_parse_BreakGuild(int fd, int guild_id) { retVal___ = HPMHooks.source.mapif.parse_BreakGuild(fd, guild_id); } if( HPMHooks.count.HP_mapif_parse_BreakGuild_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id); + int (*postHookFunc) (int retVal___, int fd, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_BreakGuild_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_BreakGuild_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id); + retVal___ = postHookFunc(retVal___, fd, guild_id); } } return retVal___; @@ -11826,11 +11818,11 @@ int HP_mapif_parse_GuildMessage(int fd, int guild_id, int account_id, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildMessage_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *fd, int *guild_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildMessage_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, &account_id, mes, &len); + retVal___ = preHookFunc(&fd, &guild_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11841,10 +11833,10 @@ int HP_mapif_parse_GuildMessage(int fd, int guild_id, int account_id, const char retVal___ = HPMHooks.source.mapif.parse_GuildMessage(fd, guild_id, account_id, mes, len); } if( HPMHooks.count.HP_mapif_parse_GuildMessage_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildMessage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, fd, guild_id, account_id, mes, len); } } return retVal___; @@ -11853,11 +11845,11 @@ int HP_mapif_parse_GuildBasicInfoChange(int fd, int guild_id, int type, const vo int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildBasicInfoChange_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, int *type, const void *data, int *len); + int (*preHookFunc) (int *fd, int *guild_id, int *type, const void **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildBasicInfoChange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildBasicInfoChange_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, &type, data, &len); + retVal___ = preHookFunc(&fd, &guild_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11868,10 +11860,10 @@ int HP_mapif_parse_GuildBasicInfoChange(int fd, int guild_id, int type, const vo retVal___ = HPMHooks.source.mapif.parse_GuildBasicInfoChange(fd, guild_id, type, data, len); } if( HPMHooks.count.HP_mapif_parse_GuildBasicInfoChange_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *type, const void *data, int *len); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int type, const void *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildBasicInfoChange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildBasicInfoChange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, fd, guild_id, type, data, len); } } return retVal___; @@ -11880,11 +11872,11 @@ int HP_mapif_parse_GuildMemberInfoChange(int fd, int guild_id, int account_id, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildMemberInfoChange_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, int *account_id, int *char_id, int *type, const char *data, int *len); + int (*preHookFunc) (int *fd, int *guild_id, int *account_id, int *char_id, int *type, const char **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMemberInfoChange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildMemberInfoChange_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = preHookFunc(&fd, &guild_id, &account_id, &char_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11895,10 +11887,10 @@ int HP_mapif_parse_GuildMemberInfoChange(int fd, int guild_id, int account_id, i retVal___ = HPMHooks.source.mapif.parse_GuildMemberInfoChange(fd, guild_id, account_id, char_id, type, data, len); } if( HPMHooks.count.HP_mapif_parse_GuildMemberInfoChange_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *account_id, int *char_id, int *type, const char *data, int *len); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int account_id, int char_id, int type, const char *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMemberInfoChange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildMemberInfoChange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, fd, guild_id, account_id, char_id, type, data, len); } } return retVal___; @@ -11907,11 +11899,11 @@ int HP_mapif_parse_GuildPosition(int fd, int guild_id, int idx, const struct gui int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildPosition_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, int *idx, const struct guild_position *p); + int (*preHookFunc) (int *fd, int *guild_id, int *idx, const struct guild_position **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildPosition_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildPosition_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, &idx, p); + retVal___ = preHookFunc(&fd, &guild_id, &idx, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11922,10 +11914,10 @@ int HP_mapif_parse_GuildPosition(int fd, int guild_id, int idx, const struct gui retVal___ = HPMHooks.source.mapif.parse_GuildPosition(fd, guild_id, idx, p); } if( HPMHooks.count.HP_mapif_parse_GuildPosition_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, int *idx, const struct guild_position *p); + int (*postHookFunc) (int retVal___, int fd, int guild_id, int idx, const struct guild_position *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildPosition_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildPosition_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &idx, p); + retVal___ = postHookFunc(retVal___, fd, guild_id, idx, p); } } return retVal___; @@ -11949,10 +11941,10 @@ int HP_mapif_parse_GuildSkillUp(int fd, int guild_id, uint16 skill_id, int accou retVal___ = HPMHooks.source.mapif.parse_GuildSkillUp(fd, guild_id, skill_id, account_id, max); } if( HPMHooks.count.HP_mapif_parse_GuildSkillUp_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, uint16 *skill_id, int *account_id, int *max); + int (*postHookFunc) (int retVal___, int fd, int guild_id, uint16 skill_id, int account_id, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildSkillUp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildSkillUp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, &skill_id, &account_id, &max); + retVal___ = postHookFunc(retVal___, fd, guild_id, skill_id, account_id, max); } } return retVal___; @@ -11961,11 +11953,11 @@ int HP_mapif_parse_GuildDeleteAlliance(struct guild *g, int guild_id, int accoun int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildDeleteAlliance_pre ) { - int (*preHookFunc) (struct guild *g, int *guild_id, int *account_id1, int *account_id2, int *flag); + int (*preHookFunc) (struct guild **g, int *guild_id, int *account_id1, int *account_id2, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildDeleteAlliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildDeleteAlliance_pre[hIndex].func; - retVal___ = preHookFunc(g, &guild_id, &account_id1, &account_id2, &flag); + retVal___ = preHookFunc(&g, &guild_id, &account_id1, &account_id2, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11976,10 +11968,10 @@ int HP_mapif_parse_GuildDeleteAlliance(struct guild *g, int guild_id, int accoun retVal___ = HPMHooks.source.mapif.parse_GuildDeleteAlliance(g, guild_id, account_id1, account_id2, flag); } if( HPMHooks.count.HP_mapif_parse_GuildDeleteAlliance_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *guild_id, int *account_id1, int *account_id2, int *flag); + int (*postHookFunc) (int retVal___, struct guild *g, int guild_id, int account_id1, int account_id2, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildDeleteAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildDeleteAlliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &guild_id, &account_id1, &account_id2, &flag); + retVal___ = postHookFunc(retVal___, g, guild_id, account_id1, account_id2, flag); } } return retVal___; @@ -12003,10 +11995,10 @@ int HP_mapif_parse_GuildAlliance(int fd, int guild_id1, int guild_id2, int accou retVal___ = HPMHooks.source.mapif.parse_GuildAlliance(fd, guild_id1, guild_id2, account_id1, account_id2, flag); } if( HPMHooks.count.HP_mapif_parse_GuildAlliance_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag); + int (*postHookFunc) (int retVal___, int fd, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildAlliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag); + retVal___ = postHookFunc(retVal___, fd, guild_id1, guild_id2, account_id1, account_id2, flag); } } return retVal___; @@ -12015,11 +12007,11 @@ int HP_mapif_parse_GuildNotice(int fd, int guild_id, const char *mes1, const cha int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildNotice_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, const char *mes1, const char *mes2); + int (*preHookFunc) (int *fd, int *guild_id, const char **mes1, const char **mes2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildNotice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildNotice_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, mes1, mes2); + retVal___ = preHookFunc(&fd, &guild_id, &mes1, &mes2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12030,10 +12022,10 @@ int HP_mapif_parse_GuildNotice(int fd, int guild_id, const char *mes1, const cha retVal___ = HPMHooks.source.mapif.parse_GuildNotice(fd, guild_id, mes1, mes2); } if( HPMHooks.count.HP_mapif_parse_GuildNotice_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, const char *mes1, const char *mes2); + int (*postHookFunc) (int retVal___, int fd, int guild_id, const char *mes1, const char *mes2); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildNotice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildNotice_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, mes1, mes2); + retVal___ = postHookFunc(retVal___, fd, guild_id, mes1, mes2); } } return retVal___; @@ -12042,11 +12034,11 @@ int HP_mapif_parse_GuildEmblem(int fd, int len, int guild_id, int dummy, const c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildEmblem_pre ) { - int (*preHookFunc) (int *fd, int *len, int *guild_id, int *dummy, const char *data); + int (*preHookFunc) (int *fd, int *len, int *guild_id, int *dummy, const char **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildEmblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildEmblem_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &len, &guild_id, &dummy, data); + retVal___ = preHookFunc(&fd, &len, &guild_id, &dummy, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12057,10 +12049,10 @@ int HP_mapif_parse_GuildEmblem(int fd, int len, int guild_id, int dummy, const c retVal___ = HPMHooks.source.mapif.parse_GuildEmblem(fd, len, guild_id, dummy, data); } if( HPMHooks.count.HP_mapif_parse_GuildEmblem_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *len, int *guild_id, int *dummy, const char *data); + int (*postHookFunc) (int retVal___, int fd, int len, int guild_id, int dummy, const char *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildEmblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildEmblem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len, &guild_id, &dummy, data); + retVal___ = postHookFunc(retVal___, fd, len, guild_id, dummy, data); } } return retVal___; @@ -12069,11 +12061,11 @@ int HP_mapif_parse_GuildCastleDataLoad(int fd, int len, const int *castle_ids) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildCastleDataLoad_pre ) { - int (*preHookFunc) (int *fd, int *len, const int *castle_ids); + int (*preHookFunc) (int *fd, int *len, const int **castle_ids); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildCastleDataLoad_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildCastleDataLoad_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &len, castle_ids); + retVal___ = preHookFunc(&fd, &len, &castle_ids); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12084,10 +12076,10 @@ int HP_mapif_parse_GuildCastleDataLoad(int fd, int len, const int *castle_ids) { retVal___ = HPMHooks.source.mapif.parse_GuildCastleDataLoad(fd, len, castle_ids); } if( HPMHooks.count.HP_mapif_parse_GuildCastleDataLoad_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *len, const int *castle_ids); + int (*postHookFunc) (int retVal___, int fd, int len, const int *castle_ids); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildCastleDataLoad_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildCastleDataLoad_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len, castle_ids); + retVal___ = postHookFunc(retVal___, fd, len, castle_ids); } } return retVal___; @@ -12111,10 +12103,10 @@ int HP_mapif_parse_GuildCastleDataSave(int fd, int castle_id, int index, int val retVal___ = HPMHooks.source.mapif.parse_GuildCastleDataSave(fd, castle_id, index, value); } if( HPMHooks.count.HP_mapif_parse_GuildCastleDataSave_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *castle_id, int *index, int *value); + int (*postHookFunc) (int retVal___, int fd, int castle_id, int index, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildCastleDataSave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildCastleDataSave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &castle_id, &index, &value); + retVal___ = postHookFunc(retVal___, fd, castle_id, index, value); } } return retVal___; @@ -12123,11 +12115,11 @@ int HP_mapif_parse_GuildMasterChange(int fd, int guild_id, const char *name, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_GuildMasterChange_pre ) { - int (*preHookFunc) (int *fd, int *guild_id, const char *name, int *len); + int (*preHookFunc) (int *fd, int *guild_id, const char **name, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMasterChange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_GuildMasterChange_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &guild_id, name, &len); + retVal___ = preHookFunc(&fd, &guild_id, &name, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12138,10 +12130,10 @@ int HP_mapif_parse_GuildMasterChange(int fd, int guild_id, const char *name, int retVal___ = HPMHooks.source.mapif.parse_GuildMasterChange(fd, guild_id, name, len); } if( HPMHooks.count.HP_mapif_parse_GuildMasterChange_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *guild_id, const char *name, int *len); + int (*postHookFunc) (int retVal___, int fd, int guild_id, const char *name, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_GuildMasterChange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_GuildMasterChange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &guild_id, name, &len); + retVal___ = postHookFunc(retVal___, fd, guild_id, name, len); } } return retVal___; @@ -12149,11 +12141,11 @@ int HP_mapif_parse_GuildMasterChange(int fd, int guild_id, const char *name, int void HP_mapif_homunculus_created(int fd, int account_id, const struct s_homunculus *sh, unsigned char flag) { int hIndex = 0; if( HPMHooks.count.HP_mapif_homunculus_created_pre ) { - void (*preHookFunc) (int *fd, int *account_id, const struct s_homunculus *sh, unsigned char *flag); + void (*preHookFunc) (int *fd, int *account_id, const struct s_homunculus **sh, unsigned char *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_created_pre[hIndex].func; - preHookFunc(&fd, &account_id, sh, &flag); + preHookFunc(&fd, &account_id, &sh, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12164,10 +12156,10 @@ void HP_mapif_homunculus_created(int fd, int account_id, const struct s_homuncul HPMHooks.source.mapif.homunculus_created(fd, account_id, sh, flag); } if( HPMHooks.count.HP_mapif_homunculus_created_post ) { - void (*postHookFunc) (int *fd, int *account_id, const struct s_homunculus *sh, unsigned char *flag); + void (*postHookFunc) (int fd, int account_id, const struct s_homunculus *sh, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_created_post[hIndex].func; - postHookFunc(&fd, &account_id, sh, &flag); + postHookFunc(fd, account_id, sh, flag); } } return; @@ -12190,10 +12182,10 @@ void HP_mapif_homunculus_deleted(int fd, int flag) { HPMHooks.source.mapif.homunculus_deleted(fd, flag); } if( HPMHooks.count.HP_mapif_homunculus_deleted_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_deleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_deleted_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -12201,11 +12193,11 @@ void HP_mapif_homunculus_deleted(int fd, int flag) { void HP_mapif_homunculus_loaded(int fd, int account_id, struct s_homunculus *hd) { int hIndex = 0; if( HPMHooks.count.HP_mapif_homunculus_loaded_pre ) { - void (*preHookFunc) (int *fd, int *account_id, struct s_homunculus *hd); + void (*preHookFunc) (int *fd, int *account_id, struct s_homunculus **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_loaded_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_loaded_pre[hIndex].func; - preHookFunc(&fd, &account_id, hd); + preHookFunc(&fd, &account_id, &hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12216,10 +12208,10 @@ void HP_mapif_homunculus_loaded(int fd, int account_id, struct s_homunculus *hd) HPMHooks.source.mapif.homunculus_loaded(fd, account_id, hd); } if( HPMHooks.count.HP_mapif_homunculus_loaded_post ) { - void (*postHookFunc) (int *fd, int *account_id, struct s_homunculus *hd); + void (*postHookFunc) (int fd, int account_id, struct s_homunculus *hd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_loaded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_loaded_post[hIndex].func; - postHookFunc(&fd, &account_id, hd); + postHookFunc(fd, account_id, hd); } } return; @@ -12242,10 +12234,10 @@ void HP_mapif_homunculus_saved(int fd, int account_id, bool flag) { HPMHooks.source.mapif.homunculus_saved(fd, account_id, flag); } if( HPMHooks.count.HP_mapif_homunculus_saved_post ) { - void (*postHookFunc) (int *fd, int *account_id, bool *flag); + void (*postHookFunc) (int fd, int account_id, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_saved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_saved_post[hIndex].func; - postHookFunc(&fd, &account_id, &flag); + postHookFunc(fd, account_id, flag); } } return; @@ -12253,11 +12245,11 @@ void HP_mapif_homunculus_saved(int fd, int account_id, bool flag) { void HP_mapif_homunculus_renamed(int fd, int account_id, int char_id, unsigned char flag, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_mapif_homunculus_renamed_pre ) { - void (*preHookFunc) (int *fd, int *account_id, int *char_id, unsigned char *flag, const char *name); + void (*preHookFunc) (int *fd, int *account_id, int *char_id, unsigned char *flag, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_renamed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_renamed_pre[hIndex].func; - preHookFunc(&fd, &account_id, &char_id, &flag, name); + preHookFunc(&fd, &account_id, &char_id, &flag, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12268,10 +12260,10 @@ void HP_mapif_homunculus_renamed(int fd, int account_id, int char_id, unsigned c HPMHooks.source.mapif.homunculus_renamed(fd, account_id, char_id, flag, name); } if( HPMHooks.count.HP_mapif_homunculus_renamed_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *char_id, unsigned char *flag, const char *name); + void (*postHookFunc) (int fd, int account_id, int char_id, unsigned char flag, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_renamed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_renamed_post[hIndex].func; - postHookFunc(&fd, &account_id, &char_id, &flag, name); + postHookFunc(fd, account_id, char_id, flag, name); } } return; @@ -12280,11 +12272,11 @@ bool HP_mapif_homunculus_create(struct s_homunculus *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_homunculus_create_pre ) { - bool (*preHookFunc) (struct s_homunculus *hd); + bool (*preHookFunc) (struct s_homunculus **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_create_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12307,11 +12299,11 @@ bool HP_mapif_homunculus_save(const struct s_homunculus *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_homunculus_save_pre ) { - bool (*preHookFunc) (const struct s_homunculus *hd); + bool (*preHookFunc) (const struct s_homunculus **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_save_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12334,11 +12326,11 @@ bool HP_mapif_homunculus_load(int homun_id, struct s_homunculus *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_homunculus_load_pre ) { - bool (*preHookFunc) (int *homun_id, struct s_homunculus *hd); + bool (*preHookFunc) (int *homun_id, struct s_homunculus **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_load_pre[hIndex].func; - retVal___ = preHookFunc(&homun_id, hd); + retVal___ = preHookFunc(&homun_id, &hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12349,10 +12341,10 @@ bool HP_mapif_homunculus_load(int homun_id, struct s_homunculus *hd) { retVal___ = HPMHooks.source.mapif.homunculus_load(homun_id, hd); } if( HPMHooks.count.HP_mapif_homunculus_load_post ) { - bool (*postHookFunc) (bool retVal___, int *homun_id, struct s_homunculus *hd); + bool (*postHookFunc) (bool retVal___, int homun_id, struct s_homunculus *hd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_load_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &homun_id, hd); + retVal___ = postHookFunc(retVal___, homun_id, hd); } } return retVal___; @@ -12376,10 +12368,10 @@ bool HP_mapif_homunculus_delete(int homun_id) { retVal___ = HPMHooks.source.mapif.homunculus_delete(homun_id); } if( HPMHooks.count.HP_mapif_homunculus_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *homun_id); + bool (*postHookFunc) (bool retVal___, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_homunculus_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &homun_id); + retVal___ = postHookFunc(retVal___, homun_id); } } return retVal___; @@ -12388,11 +12380,11 @@ bool HP_mapif_homunculus_rename(const char *name) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_homunculus_rename_pre ) { - bool (*preHookFunc) (const char *name); + bool (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_homunculus_rename_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_homunculus_rename_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12414,11 +12406,11 @@ bool HP_mapif_homunculus_rename(const char *name) { void HP_mapif_parse_homunculus_create(int fd, int len, int account_id, const struct s_homunculus *phd) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_homunculus_create_pre ) { - void (*preHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus *phd); + void (*preHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus **phd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_create_pre[hIndex].func; - preHookFunc(&fd, &len, &account_id, phd); + preHookFunc(&fd, &len, &account_id, &phd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12429,10 +12421,10 @@ void HP_mapif_parse_homunculus_create(int fd, int len, int account_id, const str HPMHooks.source.mapif.parse_homunculus_create(fd, len, account_id, phd); } if( HPMHooks.count.HP_mapif_parse_homunculus_create_post ) { - void (*postHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus *phd); + void (*postHookFunc) (int fd, int len, int account_id, const struct s_homunculus *phd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_create_post[hIndex].func; - postHookFunc(&fd, &len, &account_id, phd); + postHookFunc(fd, len, account_id, phd); } } return; @@ -12455,10 +12447,10 @@ void HP_mapif_parse_homunculus_delete(int fd, int homun_id) { HPMHooks.source.mapif.parse_homunculus_delete(fd, homun_id); } if( HPMHooks.count.HP_mapif_parse_homunculus_delete_post ) { - void (*postHookFunc) (int *fd, int *homun_id); + void (*postHookFunc) (int fd, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_delete_post[hIndex].func; - postHookFunc(&fd, &homun_id); + postHookFunc(fd, homun_id); } } return; @@ -12481,10 +12473,10 @@ void HP_mapif_parse_homunculus_load(int fd, int account_id, int homun_id) { HPMHooks.source.mapif.parse_homunculus_load(fd, account_id, homun_id); } if( HPMHooks.count.HP_mapif_parse_homunculus_load_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *homun_id); + void (*postHookFunc) (int fd, int account_id, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_load_post[hIndex].func; - postHookFunc(&fd, &account_id, &homun_id); + postHookFunc(fd, account_id, homun_id); } } return; @@ -12492,11 +12484,11 @@ void HP_mapif_parse_homunculus_load(int fd, int account_id, int homun_id) { void HP_mapif_parse_homunculus_save(int fd, int len, int account_id, const struct s_homunculus *phd) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_homunculus_save_pre ) { - void (*preHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus *phd); + void (*preHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus **phd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_save_pre[hIndex].func; - preHookFunc(&fd, &len, &account_id, phd); + preHookFunc(&fd, &len, &account_id, &phd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12507,10 +12499,10 @@ void HP_mapif_parse_homunculus_save(int fd, int len, int account_id, const struc HPMHooks.source.mapif.parse_homunculus_save(fd, len, account_id, phd); } if( HPMHooks.count.HP_mapif_parse_homunculus_save_post ) { - void (*postHookFunc) (int *fd, int *len, int *account_id, const struct s_homunculus *phd); + void (*postHookFunc) (int fd, int len, int account_id, const struct s_homunculus *phd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_save_post[hIndex].func; - postHookFunc(&fd, &len, &account_id, phd); + postHookFunc(fd, len, account_id, phd); } } return; @@ -12518,11 +12510,11 @@ void HP_mapif_parse_homunculus_save(int fd, int len, int account_id, const struc void HP_mapif_parse_homunculus_rename(int fd, int account_id, int char_id, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_homunculus_rename_pre ) { - void (*preHookFunc) (int *fd, int *account_id, int *char_id, const char *name); + void (*preHookFunc) (int *fd, int *account_id, int *char_id, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_rename_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_rename_pre[hIndex].func; - preHookFunc(&fd, &account_id, &char_id, name); + preHookFunc(&fd, &account_id, &char_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12533,10 +12525,10 @@ void HP_mapif_parse_homunculus_rename(int fd, int account_id, int char_id, const HPMHooks.source.mapif.parse_homunculus_rename(fd, account_id, char_id, name); } if( HPMHooks.count.HP_mapif_parse_homunculus_rename_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *char_id, const char *name); + void (*postHookFunc) (int fd, int account_id, int char_id, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_homunculus_rename_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_homunculus_rename_post[hIndex].func; - postHookFunc(&fd, &account_id, &char_id, name); + postHookFunc(fd, account_id, char_id, name); } } return; @@ -12544,11 +12536,11 @@ void HP_mapif_parse_homunculus_rename(int fd, int account_id, int char_id, const void HP_mapif_mail_sendinbox(int fd, int char_id, unsigned char flag, struct mail_data *md) { int hIndex = 0; if( HPMHooks.count.HP_mapif_mail_sendinbox_pre ) { - void (*preHookFunc) (int *fd, int *char_id, unsigned char *flag, struct mail_data *md); + void (*preHookFunc) (int *fd, int *char_id, unsigned char *flag, struct mail_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_sendinbox_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mail_sendinbox_pre[hIndex].func; - preHookFunc(&fd, &char_id, &flag, md); + preHookFunc(&fd, &char_id, &flag, &md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12559,10 +12551,10 @@ void HP_mapif_mail_sendinbox(int fd, int char_id, unsigned char flag, struct mai HPMHooks.source.mapif.mail_sendinbox(fd, char_id, flag, md); } if( HPMHooks.count.HP_mapif_mail_sendinbox_post ) { - void (*postHookFunc) (int *fd, int *char_id, unsigned char *flag, struct mail_data *md); + void (*postHookFunc) (int fd, int char_id, unsigned char flag, struct mail_data *md); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_sendinbox_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_sendinbox_post[hIndex].func; - postHookFunc(&fd, &char_id, &flag, md); + postHookFunc(fd, char_id, flag, md); } } return; @@ -12585,10 +12577,10 @@ void HP_mapif_parse_mail_requestinbox(int fd) { HPMHooks.source.mapif.parse_mail_requestinbox(fd); } if( HPMHooks.count.HP_mapif_parse_mail_requestinbox_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_requestinbox_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_requestinbox_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12611,10 +12603,10 @@ void HP_mapif_parse_mail_read(int fd) { HPMHooks.source.mapif.parse_mail_read(fd); } if( HPMHooks.count.HP_mapif_parse_mail_read_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_read_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12622,11 +12614,11 @@ void HP_mapif_parse_mail_read(int fd) { void HP_mapif_mail_sendattach(int fd, int char_id, struct mail_message *msg) { int hIndex = 0; if( HPMHooks.count.HP_mapif_mail_sendattach_pre ) { - void (*preHookFunc) (int *fd, int *char_id, struct mail_message *msg); + void (*preHookFunc) (int *fd, int *char_id, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_sendattach_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mail_sendattach_pre[hIndex].func; - preHookFunc(&fd, &char_id, msg); + preHookFunc(&fd, &char_id, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12637,10 +12629,10 @@ void HP_mapif_mail_sendattach(int fd, int char_id, struct mail_message *msg) { HPMHooks.source.mapif.mail_sendattach(fd, char_id, msg); } if( HPMHooks.count.HP_mapif_mail_sendattach_post ) { - void (*postHookFunc) (int *fd, int *char_id, struct mail_message *msg); + void (*postHookFunc) (int fd, int char_id, struct mail_message *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_sendattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_sendattach_post[hIndex].func; - postHookFunc(&fd, &char_id, msg); + postHookFunc(fd, char_id, msg); } } return; @@ -12663,10 +12655,10 @@ void HP_mapif_mail_getattach(int fd, int char_id, int mail_id) { HPMHooks.source.mapif.mail_getattach(fd, char_id, mail_id); } if( HPMHooks.count.HP_mapif_mail_getattach_post ) { - void (*postHookFunc) (int *fd, int *char_id, int *mail_id); + void (*postHookFunc) (int fd, int char_id, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_getattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_getattach_post[hIndex].func; - postHookFunc(&fd, &char_id, &mail_id); + postHookFunc(fd, char_id, mail_id); } } return; @@ -12689,10 +12681,10 @@ void HP_mapif_parse_mail_getattach(int fd) { HPMHooks.source.mapif.parse_mail_getattach(fd); } if( HPMHooks.count.HP_mapif_parse_mail_getattach_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_getattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_getattach_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12715,10 +12707,10 @@ void HP_mapif_mail_delete(int fd, int char_id, int mail_id, bool failed) { HPMHooks.source.mapif.mail_delete(fd, char_id, mail_id, failed); } if( HPMHooks.count.HP_mapif_mail_delete_post ) { - void (*postHookFunc) (int *fd, int *char_id, int *mail_id, bool *failed); + void (*postHookFunc) (int fd, int char_id, int mail_id, bool failed); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_delete_post[hIndex].func; - postHookFunc(&fd, &char_id, &mail_id, &failed); + postHookFunc(fd, char_id, mail_id, failed); } } return; @@ -12741,10 +12733,10 @@ void HP_mapif_parse_mail_delete(int fd) { HPMHooks.source.mapif.parse_mail_delete(fd); } if( HPMHooks.count.HP_mapif_parse_mail_delete_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_delete_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12752,11 +12744,11 @@ void HP_mapif_parse_mail_delete(int fd) { void HP_mapif_mail_new(struct mail_message *msg) { int hIndex = 0; if( HPMHooks.count.HP_mapif_mail_new_pre ) { - void (*preHookFunc) (struct mail_message *msg); + void (*preHookFunc) (struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_new_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mail_new_pre[hIndex].func; - preHookFunc(msg); + preHookFunc(&msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12793,10 +12785,10 @@ void HP_mapif_mail_return(int fd, int char_id, int mail_id, int new_mail) { HPMHooks.source.mapif.mail_return(fd, char_id, mail_id, new_mail); } if( HPMHooks.count.HP_mapif_mail_return_post ) { - void (*postHookFunc) (int *fd, int *char_id, int *mail_id, int *new_mail); + void (*postHookFunc) (int fd, int char_id, int mail_id, int new_mail); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_return_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_return_post[hIndex].func; - postHookFunc(&fd, &char_id, &mail_id, &new_mail); + postHookFunc(fd, char_id, mail_id, new_mail); } } return; @@ -12819,10 +12811,10 @@ void HP_mapif_parse_mail_return(int fd) { HPMHooks.source.mapif.parse_mail_return(fd); } if( HPMHooks.count.HP_mapif_parse_mail_return_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_return_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_return_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12830,11 +12822,11 @@ void HP_mapif_parse_mail_return(int fd) { void HP_mapif_mail_send(int fd, struct mail_message *msg) { int hIndex = 0; if( HPMHooks.count.HP_mapif_mail_send_pre ) { - void (*preHookFunc) (int *fd, struct mail_message *msg); + void (*preHookFunc) (int *fd, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mail_send_pre[hIndex].func; - preHookFunc(&fd, msg); + preHookFunc(&fd, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12845,10 +12837,10 @@ void HP_mapif_mail_send(int fd, struct mail_message *msg) { HPMHooks.source.mapif.mail_send(fd, msg); } if( HPMHooks.count.HP_mapif_mail_send_post ) { - void (*postHookFunc) (int *fd, struct mail_message *msg); + void (*postHookFunc) (int fd, struct mail_message *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mail_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mail_send_post[hIndex].func; - postHookFunc(&fd, msg); + postHookFunc(fd, msg); } } return; @@ -12871,10 +12863,10 @@ void HP_mapif_parse_mail_send(int fd) { HPMHooks.source.mapif.parse_mail_send(fd); } if( HPMHooks.count.HP_mapif_parse_mail_send_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mail_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mail_send_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -12883,11 +12875,11 @@ bool HP_mapif_mercenary_create(struct s_mercenary *merc) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_mercenary_create_pre ) { - bool (*preHookFunc) (struct s_mercenary *merc); + bool (*preHookFunc) (struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mercenary_create_pre[hIndex].func; - retVal___ = preHookFunc(merc); + retVal___ = preHookFunc(&merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12910,11 +12902,11 @@ bool HP_mapif_mercenary_save(const struct s_mercenary *merc) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_mercenary_save_pre ) { - bool (*preHookFunc) (const struct s_mercenary *merc); + bool (*preHookFunc) (const struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mercenary_save_pre[hIndex].func; - retVal___ = preHookFunc(merc); + retVal___ = preHookFunc(&merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12937,11 +12929,11 @@ bool HP_mapif_mercenary_load(int merc_id, int char_id, struct s_mercenary *merc) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapif_mercenary_load_pre ) { - bool (*preHookFunc) (int *merc_id, int *char_id, struct s_mercenary *merc); + bool (*preHookFunc) (int *merc_id, int *char_id, struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mercenary_load_pre[hIndex].func; - retVal___ = preHookFunc(&merc_id, &char_id, merc); + retVal___ = preHookFunc(&merc_id, &char_id, &merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12952,10 +12944,10 @@ bool HP_mapif_mercenary_load(int merc_id, int char_id, struct s_mercenary *merc) retVal___ = HPMHooks.source.mapif.mercenary_load(merc_id, char_id, merc); } if( HPMHooks.count.HP_mapif_mercenary_load_post ) { - bool (*postHookFunc) (bool retVal___, int *merc_id, int *char_id, struct s_mercenary *merc); + bool (*postHookFunc) (bool retVal___, int merc_id, int char_id, struct s_mercenary *merc); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mercenary_load_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &merc_id, &char_id, merc); + retVal___ = postHookFunc(retVal___, merc_id, char_id, merc); } } return retVal___; @@ -12979,10 +12971,10 @@ bool HP_mapif_mercenary_delete(int merc_id) { retVal___ = HPMHooks.source.mapif.mercenary_delete(merc_id); } if( HPMHooks.count.HP_mapif_mercenary_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *merc_id); + bool (*postHookFunc) (bool retVal___, int merc_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mercenary_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &merc_id); + retVal___ = postHookFunc(retVal___, merc_id); } } return retVal___; @@ -12990,11 +12982,11 @@ bool HP_mapif_mercenary_delete(int merc_id) { void HP_mapif_mercenary_send(int fd, struct s_mercenary *merc, unsigned char flag) { int hIndex = 0; if( HPMHooks.count.HP_mapif_mercenary_send_pre ) { - void (*preHookFunc) (int *fd, struct s_mercenary *merc, unsigned char *flag); + void (*preHookFunc) (int *fd, struct s_mercenary **merc, unsigned char *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_mercenary_send_pre[hIndex].func; - preHookFunc(&fd, merc, &flag); + preHookFunc(&fd, &merc, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13005,10 +12997,10 @@ void HP_mapif_mercenary_send(int fd, struct s_mercenary *merc, unsigned char fla HPMHooks.source.mapif.mercenary_send(fd, merc, flag); } if( HPMHooks.count.HP_mapif_mercenary_send_post ) { - void (*postHookFunc) (int *fd, struct s_mercenary *merc, unsigned char *flag); + void (*postHookFunc) (int fd, struct s_mercenary *merc, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mercenary_send_post[hIndex].func; - postHookFunc(&fd, merc, &flag); + postHookFunc(fd, merc, flag); } } return; @@ -13016,11 +13008,11 @@ void HP_mapif_mercenary_send(int fd, struct s_mercenary *merc, unsigned char fla void HP_mapif_parse_mercenary_create(int fd, const struct s_mercenary *merc) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_mercenary_create_pre ) { - void (*preHookFunc) (int *fd, const struct s_mercenary *merc); + void (*preHookFunc) (int *fd, const struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_create_pre[hIndex].func; - preHookFunc(&fd, merc); + preHookFunc(&fd, &merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13031,10 +13023,10 @@ void HP_mapif_parse_mercenary_create(int fd, const struct s_mercenary *merc) { HPMHooks.source.mapif.parse_mercenary_create(fd, merc); } if( HPMHooks.count.HP_mapif_parse_mercenary_create_post ) { - void (*postHookFunc) (int *fd, const struct s_mercenary *merc); + void (*postHookFunc) (int fd, const struct s_mercenary *merc); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_create_post[hIndex].func; - postHookFunc(&fd, merc); + postHookFunc(fd, merc); } } return; @@ -13057,10 +13049,10 @@ void HP_mapif_parse_mercenary_load(int fd, int merc_id, int char_id) { HPMHooks.source.mapif.parse_mercenary_load(fd, merc_id, char_id); } if( HPMHooks.count.HP_mapif_parse_mercenary_load_post ) { - void (*postHookFunc) (int *fd, int *merc_id, int *char_id); + void (*postHookFunc) (int fd, int merc_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_load_post[hIndex].func; - postHookFunc(&fd, &merc_id, &char_id); + postHookFunc(fd, merc_id, char_id); } } return; @@ -13083,10 +13075,10 @@ void HP_mapif_mercenary_deleted(int fd, unsigned char flag) { HPMHooks.source.mapif.mercenary_deleted(fd, flag); } if( HPMHooks.count.HP_mapif_mercenary_deleted_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_deleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mercenary_deleted_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -13109,10 +13101,10 @@ void HP_mapif_parse_mercenary_delete(int fd, int merc_id) { HPMHooks.source.mapif.parse_mercenary_delete(fd, merc_id); } if( HPMHooks.count.HP_mapif_parse_mercenary_delete_post ) { - void (*postHookFunc) (int *fd, int *merc_id); + void (*postHookFunc) (int fd, int merc_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_delete_post[hIndex].func; - postHookFunc(&fd, &merc_id); + postHookFunc(fd, merc_id); } } return; @@ -13135,10 +13127,10 @@ void HP_mapif_mercenary_saved(int fd, unsigned char flag) { HPMHooks.source.mapif.mercenary_saved(fd, flag); } if( HPMHooks.count.HP_mapif_mercenary_saved_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_mercenary_saved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_mercenary_saved_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -13146,11 +13138,11 @@ void HP_mapif_mercenary_saved(int fd, unsigned char flag) { void HP_mapif_parse_mercenary_save(int fd, const struct s_mercenary *merc) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_mercenary_save_pre ) { - void (*preHookFunc) (int *fd, const struct s_mercenary *merc); + void (*preHookFunc) (int *fd, const struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_save_pre[hIndex].func; - preHookFunc(&fd, merc); + preHookFunc(&fd, &merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13161,10 +13153,10 @@ void HP_mapif_parse_mercenary_save(int fd, const struct s_mercenary *merc) { HPMHooks.source.mapif.parse_mercenary_save(fd, merc); } if( HPMHooks.count.HP_mapif_parse_mercenary_save_post ) { - void (*postHookFunc) (int *fd, const struct s_mercenary *merc); + void (*postHookFunc) (int fd, const struct s_mercenary *merc); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_mercenary_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_mercenary_save_post[hIndex].func; - postHookFunc(&fd, merc); + postHookFunc(fd, merc); } } return; @@ -13173,11 +13165,11 @@ int HP_mapif_party_created(int fd, int account_id, int char_id, struct party *p) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_party_created_pre ) { - int (*preHookFunc) (int *fd, int *account_id, int *char_id, struct party *p); + int (*preHookFunc) (int *fd, int *account_id, int *char_id, struct party **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_party_created_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, &char_id, p); + retVal___ = preHookFunc(&fd, &account_id, &char_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13188,10 +13180,10 @@ int HP_mapif_party_created(int fd, int account_id, int char_id, struct party *p) retVal___ = HPMHooks.source.mapif.party_created(fd, account_id, char_id, p); } if( HPMHooks.count.HP_mapif_party_created_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *char_id, struct party *p); + int (*postHookFunc) (int retVal___, int fd, int account_id, int char_id, struct party *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_created_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &char_id, p); + retVal___ = postHookFunc(retVal___, fd, account_id, char_id, p); } } return retVal___; @@ -13214,10 +13206,10 @@ void HP_mapif_party_noinfo(int fd, int party_id, int char_id) { HPMHooks.source.mapif.party_noinfo(fd, party_id, char_id); } if( HPMHooks.count.HP_mapif_party_noinfo_post ) { - void (*postHookFunc) (int *fd, int *party_id, int *char_id); + void (*postHookFunc) (int fd, int party_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_noinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_noinfo_post[hIndex].func; - postHookFunc(&fd, &party_id, &char_id); + postHookFunc(fd, party_id, char_id); } } return; @@ -13225,11 +13217,11 @@ void HP_mapif_party_noinfo(int fd, int party_id, int char_id) { void HP_mapif_party_info(int fd, struct party *p, int char_id) { int hIndex = 0; if( HPMHooks.count.HP_mapif_party_info_pre ) { - void (*preHookFunc) (int *fd, struct party *p, int *char_id); + void (*preHookFunc) (int *fd, struct party **p, int *char_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_party_info_pre[hIndex].func; - preHookFunc(&fd, p, &char_id); + preHookFunc(&fd, &p, &char_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13240,10 +13232,10 @@ void HP_mapif_party_info(int fd, struct party *p, int char_id) { HPMHooks.source.mapif.party_info(fd, p, char_id); } if( HPMHooks.count.HP_mapif_party_info_post ) { - void (*postHookFunc) (int *fd, struct party *p, int *char_id); + void (*postHookFunc) (int fd, struct party *p, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_info_post[hIndex].func; - postHookFunc(&fd, p, &char_id); + postHookFunc(fd, p, char_id); } } return; @@ -13267,10 +13259,10 @@ int HP_mapif_party_memberadded(int fd, int party_id, int account_id, int char_id retVal___ = HPMHooks.source.mapif.party_memberadded(fd, party_id, account_id, char_id, flag); } if( HPMHooks.count.HP_mapif_party_memberadded_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, int *char_id, int *flag); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, int char_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_memberadded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_memberadded_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, &char_id, &flag); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, char_id, flag); } } return retVal___; @@ -13279,11 +13271,11 @@ int HP_mapif_party_optionchanged(int fd, struct party *p, int account_id, int fl int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_party_optionchanged_pre ) { - int (*preHookFunc) (int *fd, struct party *p, int *account_id, int *flag); + int (*preHookFunc) (int *fd, struct party **p, int *account_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_optionchanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_party_optionchanged_pre[hIndex].func; - retVal___ = preHookFunc(&fd, p, &account_id, &flag); + retVal___ = preHookFunc(&fd, &p, &account_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13294,10 +13286,10 @@ int HP_mapif_party_optionchanged(int fd, struct party *p, int account_id, int fl retVal___ = HPMHooks.source.mapif.party_optionchanged(fd, p, account_id, flag); } if( HPMHooks.count.HP_mapif_party_optionchanged_post ) { - int (*postHookFunc) (int retVal___, int *fd, struct party *p, int *account_id, int *flag); + int (*postHookFunc) (int retVal___, int fd, struct party *p, int account_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_optionchanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_optionchanged_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, p, &account_id, &flag); + retVal___ = postHookFunc(retVal___, fd, p, account_id, flag); } } return retVal___; @@ -13321,10 +13313,10 @@ int HP_mapif_party_withdraw(int party_id, int account_id, int char_id) { retVal___ = HPMHooks.source.mapif.party_withdraw(party_id, account_id, char_id); } if( HPMHooks.count.HP_mapif_party_withdraw_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_withdraw_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -13333,11 +13325,11 @@ int HP_mapif_party_membermoved(struct party *p, int idx) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_party_membermoved_pre ) { - int (*preHookFunc) (struct party *p, int *idx); + int (*preHookFunc) (struct party **p, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_membermoved_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_party_membermoved_pre[hIndex].func; - retVal___ = preHookFunc(p, &idx); + retVal___ = preHookFunc(&p, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13348,10 +13340,10 @@ int HP_mapif_party_membermoved(struct party *p, int idx) { retVal___ = HPMHooks.source.mapif.party_membermoved(p, idx); } if( HPMHooks.count.HP_mapif_party_membermoved_post ) { - int (*postHookFunc) (int retVal___, struct party *p, int *idx); + int (*postHookFunc) (int retVal___, struct party *p, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_membermoved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_membermoved_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &idx); + retVal___ = postHookFunc(retVal___, p, idx); } } return retVal___; @@ -13375,10 +13367,10 @@ int HP_mapif_party_broken(int party_id, int flag) { retVal___ = HPMHooks.source.mapif.party_broken(party_id, flag); } if( HPMHooks.count.HP_mapif_party_broken_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *flag); + int (*postHookFunc) (int retVal___, int party_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_broken_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &flag); + retVal___ = postHookFunc(retVal___, party_id, flag); } } return retVal___; @@ -13387,11 +13379,11 @@ int HP_mapif_party_message(int party_id, int account_id, const char *mes, int le int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_party_message_pre ) { - int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len, int *sfd); + int (*preHookFunc) (int *party_id, int *account_id, const char **mes, int *len, int *sfd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_party_message_pre[hIndex].func; - retVal___ = preHookFunc(&party_id, &account_id, mes, &len, &sfd); + retVal___ = preHookFunc(&party_id, &account_id, &mes, &len, &sfd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13402,10 +13394,10 @@ int HP_mapif_party_message(int party_id, int account_id, const char *mes, int le retVal___ = HPMHooks.source.mapif.party_message(party_id, account_id, mes, len, sfd); } if( HPMHooks.count.HP_mapif_party_message_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, const char *mes, int *len, int *sfd); + int (*postHookFunc) (int retVal___, int party_id, int account_id, const char *mes, int len, int sfd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_party_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_party_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, mes, &len, &sfd); + retVal___ = postHookFunc(retVal___, party_id, account_id, mes, len, sfd); } } return retVal___; @@ -13414,11 +13406,11 @@ int HP_mapif_parse_CreateParty(int fd, const char *name, int item, int item2, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_CreateParty_pre ) { - int (*preHookFunc) (int *fd, const char *name, int *item, int *item2, const struct party_member *leader); + int (*preHookFunc) (int *fd, const char **name, int *item, int *item2, const struct party_member **leader); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_CreateParty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_CreateParty_pre[hIndex].func; - retVal___ = preHookFunc(&fd, name, &item, &item2, leader); + retVal___ = preHookFunc(&fd, &name, &item, &item2, &leader); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13429,10 +13421,10 @@ int HP_mapif_parse_CreateParty(int fd, const char *name, int item, int item2, co retVal___ = HPMHooks.source.mapif.parse_CreateParty(fd, name, item, item2, leader); } if( HPMHooks.count.HP_mapif_parse_CreateParty_post ) { - int (*postHookFunc) (int retVal___, int *fd, const char *name, int *item, int *item2, const struct party_member *leader); + int (*postHookFunc) (int retVal___, int fd, const char *name, int item, int item2, const struct party_member *leader); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_CreateParty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_CreateParty_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, name, &item, &item2, leader); + retVal___ = postHookFunc(retVal___, fd, name, item, item2, leader); } } return retVal___; @@ -13455,10 +13447,10 @@ void HP_mapif_parse_PartyInfo(int fd, int party_id, int char_id) { HPMHooks.source.mapif.parse_PartyInfo(fd, party_id, char_id); } if( HPMHooks.count.HP_mapif_parse_PartyInfo_post ) { - void (*postHookFunc) (int *fd, int *party_id, int *char_id); + void (*postHookFunc) (int fd, int party_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyInfo_post[hIndex].func; - postHookFunc(&fd, &party_id, &char_id); + postHookFunc(fd, party_id, char_id); } } return; @@ -13467,11 +13459,11 @@ int HP_mapif_parse_PartyAddMember(int fd, int party_id, const struct party_membe int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_PartyAddMember_pre ) { - int (*preHookFunc) (int *fd, int *party_id, const struct party_member *member); + int (*preHookFunc) (int *fd, int *party_id, const struct party_member **member); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyAddMember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_PartyAddMember_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &party_id, member); + retVal___ = preHookFunc(&fd, &party_id, &member); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13482,10 +13474,10 @@ int HP_mapif_parse_PartyAddMember(int fd, int party_id, const struct party_membe retVal___ = HPMHooks.source.mapif.parse_PartyAddMember(fd, party_id, member); } if( HPMHooks.count.HP_mapif_parse_PartyAddMember_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, const struct party_member *member); + int (*postHookFunc) (int retVal___, int fd, int party_id, const struct party_member *member); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyAddMember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyAddMember_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, member); + retVal___ = postHookFunc(retVal___, fd, party_id, member); } } return retVal___; @@ -13509,10 +13501,10 @@ int HP_mapif_parse_PartyChangeOption(int fd, int party_id, int account_id, int e retVal___ = HPMHooks.source.mapif.parse_PartyChangeOption(fd, party_id, account_id, exp, item); } if( HPMHooks.count.HP_mapif_parse_PartyChangeOption_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, int *exp, int *item); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, int exp, int item); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyChangeOption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyChangeOption_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, &exp, &item); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, exp, item); } } return retVal___; @@ -13536,10 +13528,10 @@ int HP_mapif_parse_PartyLeave(int fd, int party_id, int account_id, int char_id) retVal___ = HPMHooks.source.mapif.parse_PartyLeave(fd, party_id, account_id, char_id); } if( HPMHooks.count.HP_mapif_parse_PartyLeave_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyLeave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyLeave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, char_id); } } return retVal___; @@ -13563,10 +13555,10 @@ int HP_mapif_parse_PartyChangeMap(int fd, int party_id, int account_id, int char retVal___ = HPMHooks.source.mapif.parse_PartyChangeMap(fd, party_id, account_id, char_id, map, online, lv); } if( HPMHooks.count.HP_mapif_parse_PartyChangeMap_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, int *char_id, unsigned short *map, int *online, unsigned int *lv); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, int char_id, unsigned short map, int online, unsigned int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyChangeMap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyChangeMap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, &char_id, &map, &online, &lv); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, char_id, map, online, lv); } } return retVal___; @@ -13590,10 +13582,10 @@ int HP_mapif_parse_BreakParty(int fd, int party_id) { retVal___ = HPMHooks.source.mapif.parse_BreakParty(fd, party_id); } if( HPMHooks.count.HP_mapif_parse_BreakParty_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id); + int (*postHookFunc) (int retVal___, int fd, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_BreakParty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_BreakParty_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id); + retVal___ = postHookFunc(retVal___, fd, party_id); } } return retVal___; @@ -13602,11 +13594,11 @@ int HP_mapif_parse_PartyMessage(int fd, int party_id, int account_id, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_parse_PartyMessage_pre ) { - int (*preHookFunc) (int *fd, int *party_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *fd, int *party_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_PartyMessage_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &party_id, &account_id, mes, &len); + retVal___ = preHookFunc(&fd, &party_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13617,10 +13609,10 @@ int HP_mapif_parse_PartyMessage(int fd, int party_id, int account_id, const char retVal___ = HPMHooks.source.mapif.parse_PartyMessage(fd, party_id, account_id, mes, len); } if( HPMHooks.count.HP_mapif_parse_PartyMessage_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyMessage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, mes, len); } } return retVal___; @@ -13644,10 +13636,10 @@ int HP_mapif_parse_PartyLeaderChange(int fd, int party_id, int account_id, int c retVal___ = HPMHooks.source.mapif.parse_PartyLeaderChange(fd, party_id, account_id, char_id); } if( HPMHooks.count.HP_mapif_parse_PartyLeaderChange_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int fd, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_PartyLeaderChange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_PartyLeaderChange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, fd, party_id, account_id, char_id); } } return retVal___; @@ -13656,11 +13648,11 @@ int HP_mapif_pet_created(int fd, int account_id, struct s_pet *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_pet_created_pre ) { - int (*preHookFunc) (int *fd, int *account_id, struct s_pet *p); + int (*preHookFunc) (int *fd, int *account_id, struct s_pet **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_pet_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_pet_created_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, p); + retVal___ = preHookFunc(&fd, &account_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13671,10 +13663,10 @@ int HP_mapif_pet_created(int fd, int account_id, struct s_pet *p) { retVal___ = HPMHooks.source.mapif.pet_created(fd, account_id, p); } if( HPMHooks.count.HP_mapif_pet_created_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, struct s_pet *p); + int (*postHookFunc) (int retVal___, int fd, int account_id, struct s_pet *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_pet_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_pet_created_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, p); + retVal___ = postHookFunc(retVal___, fd, account_id, p); } } return retVal___; @@ -13683,11 +13675,11 @@ int HP_mapif_pet_info(int fd, int account_id, struct s_pet *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_pet_info_pre ) { - int (*preHookFunc) (int *fd, int *account_id, struct s_pet *p); + int (*preHookFunc) (int *fd, int *account_id, struct s_pet **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_pet_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_pet_info_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, p); + retVal___ = preHookFunc(&fd, &account_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13698,10 +13690,10 @@ int HP_mapif_pet_info(int fd, int account_id, struct s_pet *p) { retVal___ = HPMHooks.source.mapif.pet_info(fd, account_id, p); } if( HPMHooks.count.HP_mapif_pet_info_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, struct s_pet *p); + int (*postHookFunc) (int retVal___, int fd, int account_id, struct s_pet *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_pet_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_pet_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, p); + retVal___ = postHookFunc(retVal___, fd, account_id, p); } } return retVal___; @@ -13725,10 +13717,10 @@ int HP_mapif_pet_noinfo(int fd, int account_id) { retVal___ = HPMHooks.source.mapif.pet_noinfo(fd, account_id); } if( HPMHooks.count.HP_mapif_pet_noinfo_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id); + int (*postHookFunc) (int retVal___, int fd, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_pet_noinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_pet_noinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id); + retVal___ = postHookFunc(retVal___, fd, account_id); } } return retVal___; @@ -13752,10 +13744,10 @@ int HP_mapif_save_pet_ack(int fd, int account_id, int flag) { retVal___ = HPMHooks.source.mapif.save_pet_ack(fd, account_id, flag); } if( HPMHooks.count.HP_mapif_save_pet_ack_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *flag); + int (*postHookFunc) (int retVal___, int fd, int account_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_save_pet_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_save_pet_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &flag); + retVal___ = postHookFunc(retVal___, fd, account_id, flag); } } return retVal___; @@ -13779,10 +13771,10 @@ int HP_mapif_delete_pet_ack(int fd, int flag) { retVal___ = HPMHooks.source.mapif.delete_pet_ack(fd, flag); } if( HPMHooks.count.HP_mapif_delete_pet_ack_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *flag); + int (*postHookFunc) (int retVal___, int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_delete_pet_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_delete_pet_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &flag); + retVal___ = postHookFunc(retVal___, fd, flag); } } return retVal___; @@ -13791,11 +13783,11 @@ int HP_mapif_create_pet(int fd, int account_id, int char_id, short pet_class, sh int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_create_pet_pre ) { - int (*preHookFunc) (int *fd, int *account_id, int *char_id, short *pet_class, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, const char *pet_name); + int (*preHookFunc) (int *fd, int *account_id, int *char_id, short *pet_class, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, const char **pet_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_create_pet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_create_pet_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, &char_id, &pet_class, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, pet_name); + retVal___ = preHookFunc(&fd, &account_id, &char_id, &pet_class, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, &pet_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13806,10 +13798,10 @@ int HP_mapif_create_pet(int fd, int account_id, int char_id, short pet_class, sh retVal___ = HPMHooks.source.mapif.create_pet(fd, account_id, char_id, pet_class, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name); } if( HPMHooks.count.HP_mapif_create_pet_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *char_id, short *pet_class, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, const char *pet_name); + int (*postHookFunc) (int retVal___, int fd, int account_id, int char_id, short pet_class, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, const char *pet_name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_create_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_create_pet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &char_id, &pet_class, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, pet_name); + retVal___ = postHookFunc(retVal___, fd, account_id, char_id, pet_class, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name); } } return retVal___; @@ -13833,10 +13825,10 @@ int HP_mapif_load_pet(int fd, int account_id, int char_id, int pet_id) { retVal___ = HPMHooks.source.mapif.load_pet(fd, account_id, char_id, pet_id); } if( HPMHooks.count.HP_mapif_load_pet_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *char_id, int *pet_id); + int (*postHookFunc) (int retVal___, int fd, int account_id, int char_id, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_load_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_load_pet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &char_id, &pet_id); + retVal___ = postHookFunc(retVal___, fd, account_id, char_id, pet_id); } } return retVal___; @@ -13845,11 +13837,11 @@ int HP_mapif_save_pet(int fd, int account_id, const struct s_pet *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_save_pet_pre ) { - int (*preHookFunc) (int *fd, int *account_id, const struct s_pet *data); + int (*preHookFunc) (int *fd, int *account_id, const struct s_pet **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_save_pet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_save_pet_pre[hIndex].func; - retVal___ = preHookFunc(&fd, &account_id, data); + retVal___ = preHookFunc(&fd, &account_id, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13860,10 +13852,10 @@ int HP_mapif_save_pet(int fd, int account_id, const struct s_pet *data) { retVal___ = HPMHooks.source.mapif.save_pet(fd, account_id, data); } if( HPMHooks.count.HP_mapif_save_pet_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, const struct s_pet *data); + int (*postHookFunc) (int retVal___, int fd, int account_id, const struct s_pet *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_save_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_save_pet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, data); + retVal___ = postHookFunc(retVal___, fd, account_id, data); } } return retVal___; @@ -13887,10 +13879,10 @@ int HP_mapif_delete_pet(int fd, int pet_id) { retVal___ = HPMHooks.source.mapif.delete_pet(fd, pet_id); } if( HPMHooks.count.HP_mapif_delete_pet_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *pet_id); + int (*postHookFunc) (int retVal___, int fd, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_delete_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_delete_pet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &pet_id); + retVal___ = postHookFunc(retVal___, fd, pet_id); } } return retVal___; @@ -13914,10 +13906,10 @@ int HP_mapif_parse_CreatePet(int fd) { retVal___ = HPMHooks.source.mapif.parse_CreatePet(fd); } if( HPMHooks.count.HP_mapif_parse_CreatePet_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_CreatePet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_CreatePet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -13941,10 +13933,10 @@ int HP_mapif_parse_LoadPet(int fd) { retVal___ = HPMHooks.source.mapif.parse_LoadPet(fd); } if( HPMHooks.count.HP_mapif_parse_LoadPet_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_LoadPet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_LoadPet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -13968,10 +13960,10 @@ int HP_mapif_parse_SavePet(int fd) { retVal___ = HPMHooks.source.mapif.parse_SavePet(fd); } if( HPMHooks.count.HP_mapif_parse_SavePet_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_SavePet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_SavePet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -13995,10 +13987,10 @@ int HP_mapif_parse_DeletePet(int fd) { retVal___ = HPMHooks.source.mapif.parse_DeletePet(fd); } if( HPMHooks.count.HP_mapif_parse_DeletePet_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_DeletePet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_DeletePet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14007,11 +13999,11 @@ struct quest* HP_mapif_quests_fromsql(int char_id, int *count) { int hIndex = 0; struct quest* retVal___ = NULL; if( HPMHooks.count.HP_mapif_quests_fromsql_pre ) { - struct quest* (*preHookFunc) (int *char_id, int *count); + struct quest* (*preHookFunc) (int *char_id, int **count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quests_fromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_quests_fromsql_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, count); + retVal___ = preHookFunc(&char_id, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14022,10 +14014,10 @@ struct quest* HP_mapif_quests_fromsql(int char_id, int *count) { retVal___ = HPMHooks.source.mapif.quests_fromsql(char_id, count); } if( HPMHooks.count.HP_mapif_quests_fromsql_post ) { - struct quest* (*postHookFunc) (struct quest* retVal___, int *char_id, int *count); + struct quest* (*postHookFunc) (struct quest* retVal___, int char_id, int *count); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quests_fromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_quests_fromsql_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, count); + retVal___ = postHookFunc(retVal___, char_id, count); } } return retVal___; @@ -14049,10 +14041,10 @@ bool HP_mapif_quest_delete(int char_id, int quest_id) { retVal___ = HPMHooks.source.mapif.quest_delete(char_id, quest_id); } if( HPMHooks.count.HP_mapif_quest_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, int *quest_id); + bool (*postHookFunc) (bool retVal___, int char_id, int quest_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quest_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_quest_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &quest_id); + retVal___ = postHookFunc(retVal___, char_id, quest_id); } } return retVal___; @@ -14076,10 +14068,10 @@ bool HP_mapif_quest_add(int char_id, struct quest qd) { retVal___ = HPMHooks.source.mapif.quest_add(char_id, qd); } if( HPMHooks.count.HP_mapif_quest_add_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, struct quest *qd); + bool (*postHookFunc) (bool retVal___, int char_id, struct quest qd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quest_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_quest_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &qd); + retVal___ = postHookFunc(retVal___, char_id, qd); } } return retVal___; @@ -14103,10 +14095,10 @@ bool HP_mapif_quest_update(int char_id, struct quest qd) { retVal___ = HPMHooks.source.mapif.quest_update(char_id, qd); } if( HPMHooks.count.HP_mapif_quest_update_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, struct quest *qd); + bool (*postHookFunc) (bool retVal___, int char_id, struct quest qd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quest_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_quest_update_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &qd); + retVal___ = postHookFunc(retVal___, char_id, qd); } } return retVal___; @@ -14129,10 +14121,10 @@ void HP_mapif_quest_save_ack(int fd, int char_id, bool success) { HPMHooks.source.mapif.quest_save_ack(fd, char_id, success); } if( HPMHooks.count.HP_mapif_quest_save_ack_post ) { - void (*postHookFunc) (int *fd, int *char_id, bool *success); + void (*postHookFunc) (int fd, int char_id, bool success); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_quest_save_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_quest_save_ack_post[hIndex].func; - postHookFunc(&fd, &char_id, &success); + postHookFunc(fd, char_id, success); } } return; @@ -14156,10 +14148,10 @@ int HP_mapif_parse_quest_save(int fd) { retVal___ = HPMHooks.source.mapif.parse_quest_save(fd); } if( HPMHooks.count.HP_mapif_parse_quest_save_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_quest_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_quest_save_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14167,11 +14159,11 @@ int HP_mapif_parse_quest_save(int fd) { void HP_mapif_send_quests(int fd, int char_id, struct quest *tmp_questlog, int num_quests) { int hIndex = 0; if( HPMHooks.count.HP_mapif_send_quests_pre ) { - void (*preHookFunc) (int *fd, int *char_id, struct quest *tmp_questlog, int *num_quests); + void (*preHookFunc) (int *fd, int *char_id, struct quest **tmp_questlog, int *num_quests); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_send_quests_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_send_quests_pre[hIndex].func; - preHookFunc(&fd, &char_id, tmp_questlog, &num_quests); + preHookFunc(&fd, &char_id, &tmp_questlog, &num_quests); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14182,10 +14174,10 @@ void HP_mapif_send_quests(int fd, int char_id, struct quest *tmp_questlog, int n HPMHooks.source.mapif.send_quests(fd, char_id, tmp_questlog, num_quests); } if( HPMHooks.count.HP_mapif_send_quests_post ) { - void (*postHookFunc) (int *fd, int *char_id, struct quest *tmp_questlog, int *num_quests); + void (*postHookFunc) (int fd, int char_id, struct quest *tmp_questlog, int num_quests); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_send_quests_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_send_quests_post[hIndex].func; - postHookFunc(&fd, &char_id, tmp_questlog, &num_quests); + postHookFunc(fd, char_id, tmp_questlog, num_quests); } } return; @@ -14209,10 +14201,10 @@ int HP_mapif_parse_quest_load(int fd) { retVal___ = HPMHooks.source.mapif.parse_quest_load(fd); } if( HPMHooks.count.HP_mapif_parse_quest_load_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_quest_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_quest_load_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14236,10 +14228,10 @@ int HP_mapif_load_guild_storage(int fd, int account_id, int guild_id, char flag) retVal___ = HPMHooks.source.mapif.load_guild_storage(fd, account_id, guild_id, flag); } if( HPMHooks.count.HP_mapif_load_guild_storage_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *guild_id, char *flag); + int (*postHookFunc) (int retVal___, int fd, int account_id, int guild_id, char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_load_guild_storage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_load_guild_storage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, fd, account_id, guild_id, flag); } } return retVal___; @@ -14263,10 +14255,10 @@ int HP_mapif_save_guild_storage_ack(int fd, int account_id, int guild_id, int fa retVal___ = HPMHooks.source.mapif.save_guild_storage_ack(fd, account_id, guild_id, fail); } if( HPMHooks.count.HP_mapif_save_guild_storage_ack_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *guild_id, int *fail); + int (*postHookFunc) (int retVal___, int fd, int account_id, int guild_id, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_save_guild_storage_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_save_guild_storage_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &guild_id, &fail); + retVal___ = postHookFunc(retVal___, fd, account_id, guild_id, fail); } } return retVal___; @@ -14290,10 +14282,10 @@ int HP_mapif_parse_LoadGuildStorage(int fd) { retVal___ = HPMHooks.source.mapif.parse_LoadGuildStorage(fd); } if( HPMHooks.count.HP_mapif_parse_LoadGuildStorage_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_LoadGuildStorage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_LoadGuildStorage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14317,10 +14309,10 @@ int HP_mapif_parse_SaveGuildStorage(int fd) { retVal___ = HPMHooks.source.mapif.parse_SaveGuildStorage(fd); } if( HPMHooks.count.HP_mapif_parse_SaveGuildStorage_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_SaveGuildStorage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_SaveGuildStorage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14344,10 +14336,10 @@ int HP_mapif_itembound_ack(int fd, int aid, int guild_id) { retVal___ = HPMHooks.source.mapif.itembound_ack(fd, aid, guild_id); } if( HPMHooks.count.HP_mapif_itembound_ack_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *aid, int *guild_id); + int (*postHookFunc) (int retVal___, int fd, int aid, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_itembound_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_itembound_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &aid, &guild_id); + retVal___ = postHookFunc(retVal___, fd, aid, guild_id); } } return retVal___; @@ -14371,10 +14363,10 @@ int HP_mapif_parse_ItemBoundRetrieve_sub(int fd) { retVal___ = HPMHooks.source.mapif.parse_ItemBoundRetrieve_sub(fd); } if( HPMHooks.count.HP_mapif_parse_ItemBoundRetrieve_sub_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_ItemBoundRetrieve_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_ItemBoundRetrieve_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14397,10 +14389,10 @@ void HP_mapif_parse_ItemBoundRetrieve(int fd) { HPMHooks.source.mapif.parse_ItemBoundRetrieve(fd); } if( HPMHooks.count.HP_mapif_parse_ItemBoundRetrieve_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_ItemBoundRetrieve_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_ItemBoundRetrieve_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -14423,10 +14415,10 @@ void HP_mapif_parse_accinfo(int fd) { HPMHooks.source.mapif.parse_accinfo(fd); } if( HPMHooks.count.HP_mapif_parse_accinfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_accinfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -14434,11 +14426,11 @@ void HP_mapif_parse_accinfo(int fd) { void HP_mapif_parse_accinfo2(bool success, int map_fd, int u_fd, int u_aid, int account_id, const char *userid, const char *user_pass, const char *email, const char *last_ip, const char *lastlogin, const char *pin_code, const char *birthdate, int group_id, int logincount, int state) { int hIndex = 0; if( HPMHooks.count.HP_mapif_parse_accinfo2_pre ) { - void (*preHookFunc) (bool *success, int *map_fd, int *u_fd, int *u_aid, int *account_id, const char *userid, const char *user_pass, const char *email, const char *last_ip, const char *lastlogin, const char *pin_code, const char *birthdate, int *group_id, int *logincount, int *state); + void (*preHookFunc) (bool *success, int *map_fd, int *u_fd, int *u_aid, int *account_id, const char **userid, const char **user_pass, const char **email, const char **last_ip, const char **lastlogin, const char **pin_code, const char **birthdate, int *group_id, int *logincount, int *state); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_accinfo2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_parse_accinfo2_pre[hIndex].func; - preHookFunc(&success, &map_fd, &u_fd, &u_aid, &account_id, userid, user_pass, email, last_ip, lastlogin, pin_code, birthdate, &group_id, &logincount, &state); + preHookFunc(&success, &map_fd, &u_fd, &u_aid, &account_id, &userid, &user_pass, &email, &last_ip, &lastlogin, &pin_code, &birthdate, &group_id, &logincount, &state); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14449,10 +14441,10 @@ void HP_mapif_parse_accinfo2(bool success, int map_fd, int u_fd, int u_aid, int HPMHooks.source.mapif.parse_accinfo2(success, map_fd, u_fd, u_aid, account_id, userid, user_pass, email, last_ip, lastlogin, pin_code, birthdate, group_id, logincount, state); } if( HPMHooks.count.HP_mapif_parse_accinfo2_post ) { - void (*postHookFunc) (bool *success, int *map_fd, int *u_fd, int *u_aid, int *account_id, const char *userid, const char *user_pass, const char *email, const char *last_ip, const char *lastlogin, const char *pin_code, const char *birthdate, int *group_id, int *logincount, int *state); + void (*postHookFunc) (bool success, int map_fd, int u_fd, int u_aid, int account_id, const char *userid, const char *user_pass, const char *email, const char *last_ip, const char *lastlogin, const char *pin_code, const char *birthdate, int group_id, int logincount, int state); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_accinfo2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_accinfo2_post[hIndex].func; - postHookFunc(&success, &map_fd, &u_fd, &u_aid, &account_id, userid, user_pass, email, last_ip, lastlogin, pin_code, birthdate, &group_id, &logincount, &state); + postHookFunc(success, map_fd, u_fd, u_aid, account_id, userid, user_pass, email, last_ip, lastlogin, pin_code, birthdate, group_id, logincount, state); } } return; @@ -14461,11 +14453,11 @@ int HP_mapif_broadcast(const unsigned char *mes, int len, unsigned int fontColor int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_broadcast_pre ) { - int (*preHookFunc) (const unsigned char *mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, int *sfd); + int (*preHookFunc) (const unsigned char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, int *sfd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_broadcast_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_broadcast_pre[hIndex].func; - retVal___ = preHookFunc(mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &sfd); + retVal___ = preHookFunc(&mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &sfd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14476,10 +14468,10 @@ int HP_mapif_broadcast(const unsigned char *mes, int len, unsigned int fontColor retVal___ = HPMHooks.source.mapif.broadcast(mes, len, fontColor, fontType, fontSize, fontAlign, fontY, sfd); } if( HPMHooks.count.HP_mapif_broadcast_post ) { - int (*postHookFunc) (int retVal___, const unsigned char *mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, int *sfd); + int (*postHookFunc) (int retVal___, const unsigned char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, int sfd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_broadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_broadcast_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &sfd); + retVal___ = postHookFunc(retVal___, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, sfd); } } return retVal___; @@ -14488,11 +14480,11 @@ int HP_mapif_wis_message(struct WisData *wd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_wis_message_pre ) { - int (*preHookFunc) (struct WisData *wd); + int (*preHookFunc) (struct WisData **wd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_wis_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_wis_message_pre[hIndex].func; - retVal___ = preHookFunc(wd); + retVal___ = preHookFunc(&wd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14514,11 +14506,11 @@ int HP_mapif_wis_message(struct WisData *wd) { void HP_mapif_wis_response(int fd, const unsigned char *src, int flag) { int hIndex = 0; if( HPMHooks.count.HP_mapif_wis_response_pre ) { - void (*preHookFunc) (int *fd, const unsigned char *src, int *flag); + void (*preHookFunc) (int *fd, const unsigned char **src, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_wis_response_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_wis_response_pre[hIndex].func; - preHookFunc(&fd, src, &flag); + preHookFunc(&fd, &src, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14529,10 +14521,10 @@ void HP_mapif_wis_response(int fd, const unsigned char *src, int flag) { HPMHooks.source.mapif.wis_response(fd, src, flag); } if( HPMHooks.count.HP_mapif_wis_response_post ) { - void (*postHookFunc) (int *fd, const unsigned char *src, int *flag); + void (*postHookFunc) (int fd, const unsigned char *src, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_wis_response_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_wis_response_post[hIndex].func; - postHookFunc(&fd, src, &flag); + postHookFunc(fd, src, flag); } } return; @@ -14541,11 +14533,11 @@ int HP_mapif_wis_end(struct WisData *wd, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapif_wis_end_pre ) { - int (*preHookFunc) (struct WisData *wd, int *flag); + int (*preHookFunc) (struct WisData **wd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_wis_end_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_wis_end_pre[hIndex].func; - retVal___ = preHookFunc(wd, &flag); + retVal___ = preHookFunc(&wd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14556,10 +14548,10 @@ int HP_mapif_wis_end(struct WisData *wd, int flag) { retVal___ = HPMHooks.source.mapif.wis_end(wd, flag); } if( HPMHooks.count.HP_mapif_wis_end_post ) { - int (*postHookFunc) (int retVal___, struct WisData *wd, int *flag); + int (*postHookFunc) (int retVal___, struct WisData *wd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_wis_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_wis_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, wd, &flag); + retVal___ = postHookFunc(retVal___, wd, flag); } } return retVal___; @@ -14583,10 +14575,10 @@ int HP_mapif_account_reg_reply(int fd, int account_id, int char_id, int type) { retVal___ = HPMHooks.source.mapif.account_reg_reply(fd, account_id, char_id, type); } if( HPMHooks.count.HP_mapif_account_reg_reply_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *char_id, int *type); + int (*postHookFunc) (int retVal___, int fd, int account_id, int char_id, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_account_reg_reply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_account_reg_reply_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &char_id, &type); + retVal___ = postHookFunc(retVal___, fd, account_id, char_id, type); } } return retVal___; @@ -14610,10 +14602,10 @@ int HP_mapif_disconnectplayer(int fd, int account_id, int char_id, int reason) { retVal___ = HPMHooks.source.mapif.disconnectplayer(fd, account_id, char_id, reason); } if( HPMHooks.count.HP_mapif_disconnectplayer_post ) { - int (*postHookFunc) (int retVal___, int *fd, int *account_id, int *char_id, int *reason); + int (*postHookFunc) (int retVal___, int fd, int account_id, int char_id, int reason); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_disconnectplayer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_disconnectplayer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &account_id, &char_id, &reason); + retVal___ = postHookFunc(retVal___, fd, account_id, char_id, reason); } } return retVal___; @@ -14637,10 +14629,10 @@ int HP_mapif_parse_broadcast(int fd) { retVal___ = HPMHooks.source.mapif.parse_broadcast(fd); } if( HPMHooks.count.HP_mapif_parse_broadcast_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_broadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_broadcast_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14664,10 +14656,10 @@ int HP_mapif_parse_WisRequest(int fd) { retVal___ = HPMHooks.source.mapif.parse_WisRequest(fd); } if( HPMHooks.count.HP_mapif_parse_WisRequest_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_WisRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_WisRequest_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14691,10 +14683,10 @@ int HP_mapif_parse_WisReply(int fd) { retVal___ = HPMHooks.source.mapif.parse_WisReply(fd); } if( HPMHooks.count.HP_mapif_parse_WisReply_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_WisReply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_WisReply_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14718,10 +14710,10 @@ int HP_mapif_parse_WisToGM(int fd) { retVal___ = HPMHooks.source.mapif.parse_WisToGM(fd); } if( HPMHooks.count.HP_mapif_parse_WisToGM_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_WisToGM_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_WisToGM_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14745,10 +14737,10 @@ int HP_mapif_parse_Registry(int fd) { retVal___ = HPMHooks.source.mapif.parse_Registry(fd); } if( HPMHooks.count.HP_mapif_parse_Registry_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_Registry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_Registry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14772,10 +14764,10 @@ int HP_mapif_parse_RegistryRequest(int fd) { retVal___ = HPMHooks.source.mapif.parse_RegistryRequest(fd); } if( HPMHooks.count.HP_mapif_parse_RegistryRequest_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_RegistryRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_RegistryRequest_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14783,11 +14775,11 @@ int HP_mapif_parse_RegistryRequest(int fd) { void HP_mapif_namechange_ack(int fd, int account_id, int char_id, int type, int flag, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_mapif_namechange_ack_pre ) { - void (*preHookFunc) (int *fd, int *account_id, int *char_id, int *type, int *flag, const char *name); + void (*preHookFunc) (int *fd, int *account_id, int *char_id, int *type, int *flag, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_namechange_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapif_namechange_ack_pre[hIndex].func; - preHookFunc(&fd, &account_id, &char_id, &type, &flag, name); + preHookFunc(&fd, &account_id, &char_id, &type, &flag, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14798,10 +14790,10 @@ void HP_mapif_namechange_ack(int fd, int account_id, int char_id, int type, int HPMHooks.source.mapif.namechange_ack(fd, account_id, char_id, type, flag, name); } if( HPMHooks.count.HP_mapif_namechange_ack_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *char_id, int *type, int *flag, const char *name); + void (*postHookFunc) (int fd, int account_id, int char_id, int type, int flag, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_namechange_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_namechange_ack_post[hIndex].func; - postHookFunc(&fd, &account_id, &char_id, &type, &flag, name); + postHookFunc(fd, account_id, char_id, type, flag, name); } } return; @@ -14825,10 +14817,10 @@ int HP_mapif_parse_NameChangeRequest(int fd) { retVal___ = HPMHooks.source.mapif.parse_NameChangeRequest(fd); } if( HPMHooks.count.HP_mapif_parse_NameChangeRequest_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapif_parse_NameChangeRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapif_parse_NameChangeRequest_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -14891,11 +14883,11 @@ int HP_mapindex_addmap(int index, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapindex_addmap_pre ) { - int (*preHookFunc) (int *index, const char *name); + int (*preHookFunc) (int *index, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_addmap_pre[hIndex].func; - retVal___ = preHookFunc(&index, name); + retVal___ = preHookFunc(&index, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14906,10 +14898,10 @@ int HP_mapindex_addmap(int index, const char *name) { retVal___ = HPMHooks.source.mapindex.addmap(index, name); } if( HPMHooks.count.HP_mapindex_addmap_post ) { - int (*postHookFunc) (int retVal___, int *index, const char *name); + int (*postHookFunc) (int retVal___, int index, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_addmap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &index, name); + retVal___ = postHookFunc(retVal___, index, name); } } return retVal___; @@ -14932,10 +14924,10 @@ void HP_mapindex_removemap(int index) { HPMHooks.source.mapindex.removemap(index); } if( HPMHooks.count.HP_mapindex_removemap_post ) { - void (*postHookFunc) (int *index); + void (*postHookFunc) (int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_removemap_post[hIndex].func; - postHookFunc(&index); + postHookFunc(index); } } return; @@ -14944,11 +14936,11 @@ const char* HP_mapindex_getmapname(const char *string, char *output) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_getmapname_pre ) { - const char* (*preHookFunc) (const char *string, char *output); + const char* (*preHookFunc) (const char **string, char **output); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_getmapname_pre[hIndex].func; - retVal___ = preHookFunc(string, output); + retVal___ = preHookFunc(&string, &output); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14971,11 +14963,11 @@ const char* HP_mapindex_getmapname_ext(const char *string, char *output) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_getmapname_ext_pre ) { - const char* (*preHookFunc) (const char *string, char *output); + const char* (*preHookFunc) (const char **string, char **output); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_pre[hIndex].func; - retVal___ = preHookFunc(string, output); + retVal___ = preHookFunc(&string, &output); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14998,11 +14990,11 @@ unsigned short HP_mapindex_name2id(const char *p1) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_mapindex_name2id_pre ) { - unsigned short (*preHookFunc) (const char *p1); + unsigned short (*preHookFunc) (const char **p1); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_name2id_pre[hIndex].func; - retVal___ = preHookFunc(p1); + retVal___ = preHookFunc(&p1); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15025,11 +15017,11 @@ const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const cha int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_id2name_pre ) { - const char* (*preHookFunc) (uint16 *id, const char *file, int *line, const char *func); + const char* (*preHookFunc) (uint16 *id, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_id2name_pre[hIndex].func; - retVal___ = preHookFunc(&id, file, &line, func); + retVal___ = preHookFunc(&id, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15040,10 +15032,10 @@ const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const cha retVal___ = HPMHooks.source.mapindex.id2name(id, file, line, func); } if( HPMHooks.count.HP_mapindex_id2name_post ) { - const char* (*postHookFunc) (const char* retVal___, uint16 *id, const char *file, int *line, const char *func); + const char* (*postHookFunc) (const char* retVal___, uint16 id, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_id2name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id, file, &line, func); + retVal___ = postHookFunc(retVal___, id, file, line, func); } } return retVal___; @@ -15079,11 +15071,11 @@ bool HP_mapindex_check_default(void) { void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { int hIndex = 0; if( HPMHooks.count.HP_nullpo_assert_report_pre ) { - void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*preHookFunc) (const char **file, int *line, const char **func, const char **targetname, const char **title); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; - preHookFunc(file, &line, func, targetname, title); + preHookFunc(&file, &line, &func, &targetname, &title); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15094,10 +15086,10 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); } if( HPMHooks.count.HP_nullpo_assert_report_post ) { - void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*postHookFunc) (const char *file, int line, const char *func, const char *targetname, const char *title); for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; - postHookFunc(file, &line, func, targetname, title); + postHookFunc(file, line, func, targetname, title); } } return; @@ -15106,11 +15098,11 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const void HP_pincode_handle(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pincode_handle_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_handle_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_handle_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15121,10 +15113,10 @@ void HP_pincode_handle(int fd, struct char_session_data *sd) { HPMHooks.source.pincode.handle(fd, sd); } if( HPMHooks.count.HP_pincode_handle_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_handle_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_handle_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -15132,11 +15124,11 @@ void HP_pincode_handle(int fd, struct char_session_data *sd) { void HP_pincode_decrypt(unsigned int userSeed, char *pin) { int hIndex = 0; if( HPMHooks.count.HP_pincode_decrypt_pre ) { - void (*preHookFunc) (unsigned int *userSeed, char *pin); + void (*preHookFunc) (unsigned int *userSeed, char **pin); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_decrypt_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_decrypt_pre[hIndex].func; - preHookFunc(&userSeed, pin); + preHookFunc(&userSeed, &pin); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15147,10 +15139,10 @@ void HP_pincode_decrypt(unsigned int userSeed, char *pin) { HPMHooks.source.pincode.decrypt(userSeed, pin); } if( HPMHooks.count.HP_pincode_decrypt_post ) { - void (*postHookFunc) (unsigned int *userSeed, char *pin); + void (*postHookFunc) (unsigned int userSeed, char *pin); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_decrypt_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_decrypt_post[hIndex].func; - postHookFunc(&userSeed, pin); + postHookFunc(userSeed, pin); } } return; @@ -15173,10 +15165,10 @@ void HP_pincode_error(int account_id) { HPMHooks.source.pincode.error(account_id); } if( HPMHooks.count.HP_pincode_error_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_error_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -15184,11 +15176,11 @@ void HP_pincode_error(int account_id) { void HP_pincode_update(int account_id, char *pin) { int hIndex = 0; if( HPMHooks.count.HP_pincode_update_pre ) { - void (*preHookFunc) (int *account_id, char *pin); + void (*preHookFunc) (int *account_id, char **pin); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_update_pre[hIndex].func; - preHookFunc(&account_id, pin); + preHookFunc(&account_id, &pin); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15199,10 +15191,10 @@ void HP_pincode_update(int account_id, char *pin) { HPMHooks.source.pincode.update(account_id, pin); } if( HPMHooks.count.HP_pincode_update_post ) { - void (*postHookFunc) (int *account_id, char *pin); + void (*postHookFunc) (int account_id, char *pin); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_update_post[hIndex].func; - postHookFunc(&account_id, pin); + postHookFunc(account_id, pin); } } return; @@ -15210,11 +15202,11 @@ void HP_pincode_update(int account_id, char *pin) { void HP_pincode_sendstate(int fd, struct char_session_data *sd, uint16 state) { int hIndex = 0; if( HPMHooks.count.HP_pincode_sendstate_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd, uint16 *state); + void (*preHookFunc) (int *fd, struct char_session_data **sd, uint16 *state); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_sendstate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_sendstate_pre[hIndex].func; - preHookFunc(&fd, sd, &state); + preHookFunc(&fd, &sd, &state); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15225,10 +15217,10 @@ void HP_pincode_sendstate(int fd, struct char_session_data *sd, uint16 state) { HPMHooks.source.pincode.sendstate(fd, sd, state); } if( HPMHooks.count.HP_pincode_sendstate_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd, uint16 *state); + void (*postHookFunc) (int fd, struct char_session_data *sd, uint16 state); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_sendstate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_sendstate_post[hIndex].func; - postHookFunc(&fd, sd, &state); + postHookFunc(fd, sd, state); } } return; @@ -15236,11 +15228,11 @@ void HP_pincode_sendstate(int fd, struct char_session_data *sd, uint16 state) { void HP_pincode_setnew(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pincode_setnew_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_setnew_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_setnew_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15251,10 +15243,10 @@ void HP_pincode_setnew(int fd, struct char_session_data *sd) { HPMHooks.source.pincode.setnew(fd, sd); } if( HPMHooks.count.HP_pincode_setnew_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_setnew_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_setnew_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -15262,11 +15254,11 @@ void HP_pincode_setnew(int fd, struct char_session_data *sd) { void HP_pincode_change(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pincode_change_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_change_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15277,10 +15269,10 @@ void HP_pincode_change(int fd, struct char_session_data *sd) { HPMHooks.source.pincode.change(fd, sd); } if( HPMHooks.count.HP_pincode_change_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_change_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -15289,11 +15281,11 @@ int HP_pincode_compare(int fd, struct char_session_data *sd, char *pin) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pincode_compare_pre ) { - int (*preHookFunc) (int *fd, struct char_session_data *sd, char *pin); + int (*preHookFunc) (int *fd, struct char_session_data **sd, char **pin); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_compare_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_compare_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd, pin); + retVal___ = preHookFunc(&fd, &sd, &pin); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15304,10 +15296,10 @@ int HP_pincode_compare(int fd, struct char_session_data *sd, char *pin) { retVal___ = HPMHooks.source.pincode.compare(fd, sd, pin); } if( HPMHooks.count.HP_pincode_compare_post ) { - int (*postHookFunc) (int retVal___, int *fd, struct char_session_data *sd, char *pin); + int (*postHookFunc) (int retVal___, int fd, struct char_session_data *sd, char *pin); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_compare_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_compare_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd, pin); + retVal___ = postHookFunc(retVal___, fd, sd, pin); } } return retVal___; @@ -15315,11 +15307,11 @@ int HP_pincode_compare(int fd, struct char_session_data *sd, char *pin) { void HP_pincode_check(int fd, struct char_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pincode_check_pre ) { - void (*preHookFunc) (int *fd, struct char_session_data *sd); + void (*preHookFunc) (int *fd, struct char_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_check_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15330,10 +15322,10 @@ void HP_pincode_check(int fd, struct char_session_data *sd) { HPMHooks.source.pincode.check(fd, sd); } if( HPMHooks.count.HP_pincode_check_post ) { - void (*postHookFunc) (int *fd, struct char_session_data *sd); + void (*postHookFunc) (int fd, struct char_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pincode_check_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -15342,11 +15334,11 @@ bool HP_pincode_config_read(char *w1, char *w2) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pincode_config_read_pre ) { - bool (*preHookFunc) (char *w1, char *w2); + bool (*preHookFunc) (char **w1, char **w2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pincode_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pincode_config_read_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2); + retVal___ = preHookFunc(&w1, &w2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15448,12 +15440,12 @@ int HP_showmsg_showMessageV(const char *string, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { - int (*preHookFunc) (const char *string, va_list ap); + int (*preHookFunc) (const char **string, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; - retVal___ = preHookFunc(string, ap___copy); + retVal___ = preHookFunc(&string, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -15549,10 +15541,10 @@ int HP_sockt_perform(int next) { retVal___ = HPMHooks.source.sockt.perform(next); } if( HPMHooks.count.HP_sockt_perform_post ) { - int (*postHookFunc) (int retVal___, int *next); + int (*postHookFunc) (int retVal___, int next); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &next); + retVal___ = postHookFunc(retVal___, next); } } return retVal___; @@ -15575,10 +15567,10 @@ void HP_sockt_datasync(int fd, bool send) { HPMHooks.source.sockt.datasync(fd, send); } if( HPMHooks.count.HP_sockt_datasync_post ) { - void (*postHookFunc) (int *fd, bool *send); + void (*postHookFunc) (int fd, bool send); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; - postHookFunc(&fd, &send); + postHookFunc(fd, send); } } return; @@ -15602,10 +15594,10 @@ int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); } if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port); + retVal___ = postHookFunc(retVal___, ip, port); } } return retVal___; @@ -15614,11 +15606,11 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_make_connection_pre ) { - int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; - retVal___ = preHookFunc(&ip, &port, opt); + retVal___ = preHookFunc(&ip, &port, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15629,10 +15621,10 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); } if( HPMHooks.count.HP_sockt_make_connection_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port, struct hSockOpt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port, opt); + retVal___ = postHookFunc(retVal___, ip, port, opt); } } return retVal___; @@ -15656,10 +15648,10 @@ int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_si retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); } if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + int (*postHookFunc) (int retVal___, int fd, unsigned int rfifo_size, unsigned int wfifo_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + retVal___ = postHookFunc(retVal___, fd, rfifo_size, wfifo_size); } } return retVal___; @@ -15683,10 +15675,10 @@ int HP_sockt_realloc_writefifo(int fd, size_t addition) { retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); } if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + int (*postHookFunc) (int retVal___, int fd, size_t addition); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &addition); + retVal___ = postHookFunc(retVal___, fd, addition); } } return retVal___; @@ -15710,10 +15702,10 @@ int HP_sockt_wfifoset(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); } if( HPMHooks.count.HP_sockt_wfifoset_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -15737,10 +15729,10 @@ int HP_sockt_rfifoskip(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); } if( HPMHooks.count.HP_sockt_rfifoskip_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -15763,10 +15755,10 @@ void HP_sockt_close(int fd) { HPMHooks.source.sockt.close(fd); } if( HPMHooks.count.HP_sockt_close_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -15790,10 +15782,10 @@ bool HP_sockt_session_is_valid(int fd) { retVal___ = HPMHooks.source.sockt.session_is_valid(fd); } if( HPMHooks.count.HP_sockt_session_is_valid_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -15817,10 +15809,10 @@ bool HP_sockt_session_is_active(int fd) { retVal___ = HPMHooks.source.sockt.session_is_active(fd); } if( HPMHooks.count.HP_sockt_session_is_active_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -15843,10 +15835,10 @@ void HP_sockt_flush(int fd) { HPMHooks.source.sockt.flush(fd); } if( HPMHooks.count.HP_sockt_flush_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -15895,10 +15887,10 @@ void HP_sockt_set_nonblocking(int fd, unsigned long yes) { HPMHooks.source.sockt.set_nonblocking(fd, yes); } if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { - void (*postHookFunc) (int *fd, unsigned long *yes); + void (*postHookFunc) (int fd, unsigned long yes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; - postHookFunc(&fd, &yes); + postHookFunc(fd, yes); } } return; @@ -15921,10 +15913,10 @@ void HP_sockt_set_defaultparse(ParseFunc defaultparse) { HPMHooks.source.sockt.set_defaultparse(defaultparse); } if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { - void (*postHookFunc) (ParseFunc *defaultparse); + void (*postHookFunc) (ParseFunc defaultparse); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; - postHookFunc(&defaultparse); + postHookFunc(defaultparse); } } return; @@ -15933,11 +15925,11 @@ uint32 HP_sockt_host2ip(const char *hostname) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_host2ip_pre ) { - uint32 (*preHookFunc) (const char *hostname); + uint32 (*preHookFunc) (const char **hostname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; - retVal___ = preHookFunc(hostname); + retVal___ = preHookFunc(&hostname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15960,11 +15952,11 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sockt_ip2str_pre ) { - const char* (*preHookFunc) (uint32 *ip, char *ip_str); + const char* (*preHookFunc) (uint32 *ip, char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; - retVal___ = preHookFunc(&ip, ip_str); + retVal___ = preHookFunc(&ip, &ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15975,10 +15967,10 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); } if( HPMHooks.count.HP_sockt_ip2str_post ) { - const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + const char* (*postHookFunc) (const char* retVal___, uint32 ip, char *ip_str); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, ip_str); + retVal___ = postHookFunc(retVal___, ip, ip_str); } } return retVal___; @@ -15987,11 +15979,11 @@ uint32 HP_sockt_str2ip(const char *ip_str) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_str2ip_pre ) { - uint32 (*preHookFunc) (const char *ip_str); + uint32 (*preHookFunc) (const char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; - retVal___ = preHookFunc(ip_str); + retVal___ = preHookFunc(&ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16029,10 +16021,10 @@ uint16 HP_sockt_ntows(uint16 netshort) { retVal___ = HPMHooks.source.sockt.ntows(netshort); } if( HPMHooks.count.HP_sockt_ntows_post ) { - uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + uint16 (*postHookFunc) (uint16 retVal___, uint16 netshort); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &netshort); + retVal___ = postHookFunc(retVal___, netshort); } } return retVal___; @@ -16041,11 +16033,11 @@ int HP_sockt_getips(uint32 *ips, int max) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_getips_pre ) { - int (*preHookFunc) (uint32 *ips, int *max); + int (*preHookFunc) (uint32 **ips, int *max); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; - retVal___ = preHookFunc(ips, &max); + retVal___ = preHookFunc(&ips, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16056,10 +16048,10 @@ int HP_sockt_getips(uint32 *ips, int max) { retVal___ = HPMHooks.source.sockt.getips(ips, max); } if( HPMHooks.count.HP_sockt_getips_post ) { - int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + int (*postHookFunc) (int retVal___, uint32 *ips, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ips, &max); + retVal___ = postHookFunc(retVal___, ips, max); } } return retVal___; @@ -16082,10 +16074,10 @@ void HP_sockt_eof(int fd) { HPMHooks.source.sockt.eof(fd); } if( HPMHooks.count.HP_sockt_eof_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -16094,11 +16086,11 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { - uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet **info); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; - retVal___ = preHookFunc(&ip, info); + retVal___ = preHookFunc(&ip, &info); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16109,10 +16101,10 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); } if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + uint32 (*postHookFunc) (uint32 retVal___, uint32 ip, struct s_subnet *info); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, info); + retVal___ = postHookFunc(retVal___, ip, info); } } return retVal___; @@ -16136,10 +16128,10 @@ bool HP_sockt_allowed_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); } if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -16163,10 +16155,10 @@ bool HP_sockt_trusted_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); } if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -16175,11 +16167,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname); + int (*preHookFunc) (struct config_setting_t **t, struct s_subnet_vector **list, const char **filename, const char **groupname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; - retVal___ = preHookFunc(t, list, filename, groupname); + retVal___ = preHookFunc(&t, &list, &filename, &groupname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16201,11 +16193,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec void HP_sockt_net_config_read(const char *filename) { int hIndex = 0; if( HPMHooks.count.HP_sockt_net_config_read_pre ) { - void (*preHookFunc) (const char *filename); + void (*preHookFunc) (const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; - preHookFunc(filename); + preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16229,11 +16221,11 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Connect_pre ) { - int (*preHookFunc) (struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*preHookFunc) (struct Sql **self, const char **user, const char **passwd, const char **host, uint16 *port, const char **db); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; - retVal___ = preHookFunc(self, user, passwd, host, &port, db); + retVal___ = preHookFunc(&self, &user, &passwd, &host, &port, &db); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16244,10 +16236,10 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); } if( HPMHooks.count.HP_SQL_Connect_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + retVal___ = postHookFunc(retVal___, self, user, passwd, host, port, db); } } return retVal___; @@ -16256,11 +16248,11 @@ int HP_SQL_GetTimeout(struct Sql *self, uint32 *out_timeout) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { - int (*preHookFunc) (struct Sql *self, uint32 *out_timeout); + int (*preHookFunc) (struct Sql **self, uint32 **out_timeout); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; - retVal___ = preHookFunc(self, out_timeout); + retVal___ = preHookFunc(&self, &out_timeout); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16283,11 +16275,11 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { - int (*preHookFunc) (struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*preHookFunc) (struct Sql **self, const char **table, char **out_buf, size_t *buf_len, char *sep); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; - retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + retVal___ = preHookFunc(&self, &table, &out_buf, &buf_len, &sep); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16298,10 +16290,10 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); } if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + retVal___ = postHookFunc(retVal___, self, table, out_buf, buf_len, sep); } } return retVal___; @@ -16310,11 +16302,11 @@ int HP_SQL_SetEncoding(struct Sql *self, const char *encoding) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { - int (*preHookFunc) (struct Sql *self, const char *encoding); + int (*preHookFunc) (struct Sql **self, const char **encoding); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; - retVal___ = preHookFunc(self, encoding); + retVal___ = preHookFunc(&self, &encoding); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16337,11 +16329,11 @@ int HP_SQL_Ping(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Ping_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16364,11 +16356,11 @@ size_t HP_SQL_EscapeString(struct Sql *self, char *out_to, const char *from) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeString_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from); + retVal___ = preHookFunc(&self, &out_to, &from); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16391,11 +16383,11 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from, size_t *from_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from, &from_len); + retVal___ = preHookFunc(&self, &out_to, &from, &from_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16406,10 +16398,10 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); } if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { - size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t from_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + retVal___ = postHookFunc(retVal___, self, out_to, from, from_len); } } return retVal___; @@ -16418,12 +16410,12 @@ int HP_SQL_QueryV(struct Sql *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryV_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query, va_list args); + int (*preHookFunc) (struct Sql **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -16451,11 +16443,11 @@ int HP_SQL_QueryStr(struct Sql *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryStr_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query); + int (*preHookFunc) (struct Sql **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16478,11 +16470,11 @@ uint64 HP_SQL_LastInsertId(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16505,11 +16497,11 @@ uint32 HP_SQL_NumColumns(struct Sql *self) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumColumns_pre ) { - uint32 (*preHookFunc) (struct Sql *self); + uint32 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16532,11 +16524,11 @@ uint64 HP_SQL_NumRows(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumRows_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16559,11 +16551,11 @@ int HP_SQL_NextRow(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_NextRow_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16586,11 +16578,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetData_pre ) { - int (*preHookFunc) (struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*preHookFunc) (struct Sql **self, size_t *col, char ***out_buf, size_t **out_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; - retVal___ = preHookFunc(self, &col, out_buf, out_len); + retVal___ = preHookFunc(&self, &col, &out_buf, &out_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16601,10 +16593,10 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); } if( HPMHooks.count.HP_SQL_GetData_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*postHookFunc) (int retVal___, struct Sql *self, size_t col, char **out_buf, size_t *out_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + retVal___ = postHookFunc(retVal___, self, col, out_buf, out_len); } } return retVal___; @@ -16612,11 +16604,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len void HP_SQL_FreeResult(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_FreeResult_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16638,11 +16630,11 @@ void HP_SQL_FreeResult(struct Sql *self) { void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { - void (*preHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct Sql **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16653,10 +16645,10 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_ShowDebug__post ) { - void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -16664,11 +16656,11 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned void HP_SQL_Free(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_Free_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16718,11 +16710,11 @@ struct SqlStmt* HP_SQL_StmtMalloc(struct Sql *sql) { int hIndex = 0; struct SqlStmt* retVal___ = NULL; if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { - struct SqlStmt* (*preHookFunc) (struct Sql *sql); + struct SqlStmt* (*preHookFunc) (struct Sql **sql); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; - retVal___ = preHookFunc(sql); + retVal___ = preHookFunc(&sql); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16745,12 +16737,12 @@ int HP_SQL_StmtPrepareV(struct SqlStmt *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query, va_list args); + int (*preHookFunc) (struct SqlStmt **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -16778,11 +16770,11 @@ int HP_SQL_StmtPrepareStr(struct SqlStmt *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query); + int (*preHookFunc) (struct SqlStmt **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16805,11 +16797,11 @@ size_t HP_SQL_StmtNumParams(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16832,11 +16824,11 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const void **buffer, size_t *buffer_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16847,10 +16839,10 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); } if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len); } } return retVal___; @@ -16859,11 +16851,11 @@ int HP_SQL_StmtExecute(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16886,11 +16878,11 @@ uint64 HP_SQL_StmtLastInsertId(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16913,11 +16905,11 @@ size_t HP_SQL_StmtNumColumns(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16940,11 +16932,11 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, void **buffer, size_t *buffer_len, uint32 **out_length, int8 **out_is_null); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len, &out_length, &out_is_null); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16955,10 +16947,10 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } } return retVal___; @@ -16967,11 +16959,11 @@ uint64 HP_SQL_StmtNumRows(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16994,11 +16986,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17020,11 +17012,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { void HP_SQL_StmtFreeResult(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17046,11 +17038,11 @@ void HP_SQL_StmtFreeResult(struct SqlStmt *self) { void HP_SQL_StmtFree(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFree_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17072,11 +17064,11 @@ void HP_SQL_StmtFree(struct SqlStmt *self) { void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { - void (*preHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct SqlStmt **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17087,10 +17079,10 @@ void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const u HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { - void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -17126,11 +17118,11 @@ StringBuf* HP_StrBuf_Malloc(void) { void HP_StrBuf_Init(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Init_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17153,12 +17145,12 @@ int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { - int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + int (*preHookFunc) (StringBuf **self, const char **fmt, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; - retVal___ = preHookFunc(self, fmt, args___copy); + retVal___ = preHookFunc(&self, &fmt, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -17186,11 +17178,11 @@ int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Append_pre ) { - int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + int (*preHookFunc) (StringBuf **self, const StringBuf **sbuf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; - retVal___ = preHookFunc(self, sbuf); + retVal___ = preHookFunc(&self, &sbuf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17213,11 +17205,11 @@ int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { - int (*preHookFunc) (StringBuf *self, const char *str); + int (*preHookFunc) (StringBuf **self, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; - retVal___ = preHookFunc(self, str); + retVal___ = preHookFunc(&self, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17240,11 +17232,11 @@ int HP_StrBuf_Length(StringBuf *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Length_pre ) { - int (*preHookFunc) (StringBuf *self); + int (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17267,11 +17259,11 @@ char* HP_StrBuf_Value(StringBuf *self) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_StrBuf_Value_pre ) { - char* (*preHookFunc) (StringBuf *self); + char* (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17293,11 +17285,11 @@ char* HP_StrBuf_Value(StringBuf *self) { void HP_StrBuf_Clear(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Clear_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17319,11 +17311,11 @@ void HP_StrBuf_Clear(StringBuf *self) { void HP_StrBuf_Destroy(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17345,11 +17337,11 @@ void HP_StrBuf_Destroy(StringBuf *self) { void HP_StrBuf_Free(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Free_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17373,11 +17365,11 @@ char* HP_strlib_jstrescape(char *pt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescape_pre ) { - char* (*preHookFunc) (char *pt); + char* (*preHookFunc) (char **pt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; - retVal___ = preHookFunc(pt); + retVal___ = preHookFunc(&pt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17400,11 +17392,11 @@ char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { - char* (*preHookFunc) (char *pt, const char *spt); + char* (*preHookFunc) (char **pt, const char **spt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt); + retVal___ = preHookFunc(&pt, &spt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17427,11 +17419,11 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { - int (*preHookFunc) (char *pt, const char *spt, int *size); + int (*preHookFunc) (char **pt, const char **spt, int *size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt, &size); + retVal___ = preHookFunc(&pt, &spt, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17442,10 +17434,10 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); } if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { - int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int size); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pt, spt, &size); + retVal___ = postHookFunc(retVal___, pt, spt, size); } } return retVal___; @@ -17454,11 +17446,11 @@ int HP_strlib_remove_control_chars_(char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { - int (*preHookFunc) (char *str); + int (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17481,11 +17473,11 @@ char* HP_strlib_trim_(char *str) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_trim__pre ) { - char* (*preHookFunc) (char *str); + char* (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17508,11 +17500,11 @@ char* HP_strlib_normalize_name_(char *str, const char *delims) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_normalize_name__pre ) { - char* (*preHookFunc) (char *str, const char *delims); + char* (*preHookFunc) (char **str, const char **delims); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; - retVal___ = preHookFunc(str, delims); + retVal___ = preHookFunc(&str, &delims); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17535,11 +17527,11 @@ const char* HP_strlib_stristr_(const char *haystack, const char *needle) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_stristr__pre ) { - const char* (*preHookFunc) (const char *haystack, const char *needle); + const char* (*preHookFunc) (const char **haystack, const char **needle); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; - retVal___ = preHookFunc(haystack, needle); + retVal___ = preHookFunc(&haystack, &needle); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17562,11 +17554,11 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_strnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17577,10 +17569,10 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_strnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -17589,11 +17581,11 @@ char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_strtok_r__pre ) { - char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + char* (*preHookFunc) (char **s1, const char **s2, char ***lasts); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; - retVal___ = preHookFunc(s1, s2, lasts); + retVal___ = preHookFunc(&s1, &s2, &lasts); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17616,11 +17608,11 @@ int HP_strlib_e_mail_check_(char *email) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { - int (*preHookFunc) (char *email); + int (*preHookFunc) (char **email); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; - retVal___ = preHookFunc(email); + retVal___ = preHookFunc(&email); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17643,11 +17635,11 @@ int HP_strlib_config_switch_(const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_config_switch__pre ) { - int (*preHookFunc) (const char *str); + int (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17670,11 +17662,11 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { - char* (*preHookFunc) (char *dst, const char *src, size_t *n); + char* (*preHookFunc) (char **dst, const char **src, size_t *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; - retVal___ = preHookFunc(dst, src, &n); + retVal___ = preHookFunc(&dst, &src, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17685,10 +17677,10 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); } if( HPMHooks.count.HP_strlib_safestrncpy__post ) { - char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t n); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; - retVal___ = postHookFunc(retVal___, dst, src, &n); + retVal___ = postHookFunc(retVal___, dst, src, n); } } return retVal___; @@ -17697,11 +17689,11 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17712,10 +17704,10 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_safestrnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -17724,11 +17716,11 @@ int HP_strlib_strline_(const char *str, size_t pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_strline__pre ) { - int (*preHookFunc) (const char *str, size_t *pos); + int (*preHookFunc) (const char **str, size_t *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; - retVal___ = preHookFunc(str, &pos); + retVal___ = preHookFunc(&str, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17739,10 +17731,10 @@ int HP_strlib_strline_(const char *str, size_t pos) { retVal___ = HPMHooks.source.strlib.strline_(str, pos); } if( HPMHooks.count.HP_strlib_strline__post ) { - int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + int (*postHookFunc) (int retVal___, const char *str, size_t pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &pos); + retVal___ = postHookFunc(retVal___, str, pos); } } return retVal___; @@ -17751,11 +17743,11 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_strlib_bin2hex__pre ) { - bool (*preHookFunc) (char *output, const unsigned char *input, size_t *count); + bool (*preHookFunc) (char **output, const unsigned char **input, size_t *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; - retVal___ = preHookFunc(output, input, &count); + retVal___ = preHookFunc(&output, &input, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17766,10 +17758,10 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); } if( HPMHooks.count.HP_strlib_bin2hex__post ) { - bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t *count); + bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t count); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; - retVal___ = postHookFunc(retVal___, output, input, &count); + retVal___ = postHookFunc(retVal___, output, input, count); } } return retVal___; @@ -17779,11 +17771,11 @@ int HP_sv_parse_next(struct s_svstate *svstate) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_next_pre ) { - int (*preHookFunc) (struct s_svstate *svstate); + int (*preHookFunc) (struct s_svstate **svstate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; - retVal___ = preHookFunc(svstate); + retVal___ = preHookFunc(&svstate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17806,11 +17798,11 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_pre ) { - int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*preHookFunc) (const char **str, int *len, int *startoff, char *delim, int **out_pos, int *npos, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_pos, &npos, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17821,10 +17813,10 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); } if( HPMHooks.count.HP_sv_parse_post ) { - int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_pos, npos, opt); } } return retVal___; @@ -17833,11 +17825,11 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_split_pre ) { - int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*preHookFunc) (char **str, int *len, int *startoff, char *delim, char ***out_fields, int *nfields, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_fields, &nfields, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17848,10 +17840,10 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); } if( HPMHooks.count.HP_sv_split_post ) { - int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_fields, nfields, opt); } } return retVal___; @@ -17860,11 +17852,11 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_escape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len, const char **escapes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len, escapes); + retVal___ = preHookFunc(&out_dest, &src, &len, &escapes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17875,10 +17867,10 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); } if( HPMHooks.count.HP_sv_escape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len, const char *escapes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + retVal___ = postHookFunc(retVal___, out_dest, src, len, escapes); } } return retVal___; @@ -17887,11 +17879,11 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_unescape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len); + retVal___ = preHookFunc(&out_dest, &src, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17902,10 +17894,10 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); } if( HPMHooks.count.HP_sv_unescape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len); + retVal___ = postHookFunc(retVal___, out_dest, src, len); } } return retVal___; @@ -17914,11 +17906,11 @@ const char* HP_sv_skip_escaped_c(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17941,11 +17933,11 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_sv_readdb_pre ) { - bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*preHookFunc) (const char **directory, const char **filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( **parseproc ) (char *fields[], int columns, int current)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; - retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = preHookFunc(&directory, &filename, &delim, &mincols, &maxcols, &maxrows, &parseproc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17956,10 +17948,10 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); } if( HPMHooks.count.HP_sv_readdb_post ) { - bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = postHookFunc(retVal___, directory, filename, delim, mincols, maxcols, maxrows, parseproc); } } return retVal___; @@ -18522,10 +18514,10 @@ int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { retVal___ = HPMHooks.source.timer.add(tick, func, id, data); } if( HPMHooks.count.HP_timer_add_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + retVal___ = postHookFunc(retVal___, tick, func, id, data); } } return retVal___; @@ -18549,10 +18541,10 @@ int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); } if( HPMHooks.count.HP_timer_add_interval_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data, int interval); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + retVal___ = postHookFunc(retVal___, tick, func, id, data, interval); } } return retVal___; @@ -18576,10 +18568,10 @@ const struct TimerData* HP_timer_get(int tid) { retVal___ = HPMHooks.source.timer.get(tid); } if( HPMHooks.count.HP_timer_get_post ) { - const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int tid); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid); + retVal___ = postHookFunc(retVal___, tid); } } return retVal___; @@ -18603,10 +18595,10 @@ int HP_timer_delete(int tid, TimerFunc func) { retVal___ = HPMHooks.source.timer.delete(tid, func); } if( HPMHooks.count.HP_timer_delete_post ) { - int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + int (*postHookFunc) (int retVal___, int tid, TimerFunc func); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &func); + retVal___ = postHookFunc(retVal___, tid, func); } } return retVal___; @@ -18630,10 +18622,10 @@ int64 HP_timer_addtick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.addtick(tid, tick); } if( HPMHooks.count.HP_timer_addtick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -18657,10 +18649,10 @@ int64 HP_timer_settick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.settick(tid, tick); } if( HPMHooks.count.HP_timer_settick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -18669,11 +18661,11 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_timer_add_func_list_pre ) { - int (*preHookFunc) (TimerFunc *func, char *name); + int (*preHookFunc) (TimerFunc *func, char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; - retVal___ = preHookFunc(&func, name); + retVal___ = preHookFunc(&func, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18684,10 +18676,10 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { retVal___ = HPMHooks.source.timer.add_func_list(func, name); } if( HPMHooks.count.HP_timer_add_func_list_post ) { - int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + int (*postHookFunc) (int retVal___, TimerFunc func, char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &func, name); + retVal___ = postHookFunc(retVal___, func, name); } } return retVal___; @@ -18738,10 +18730,10 @@ int HP_timer_perform(int64 tick) { retVal___ = HPMHooks.source.timer.perform(tick); } if( HPMHooks.count.HP_timer_perform_post ) { - int (*postHookFunc) (int retVal___, int64 *tick); + int (*postHookFunc) (int retVal___, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick); + retVal___ = postHookFunc(retVal___, tick); } } return retVal___; diff --git a/src/plugins/HPMHooking/HPMHooking_char.sources.inc b/src/plugins/HPMHooking/HPMHooking_char.sources.inc index d14117add..21d1f6531 100644 --- a/src/plugins/HPMHooking/HPMHooking_char.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_char.sources.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); memcpy(&HPMHooks.source.chr, chr, sizeof(struct char_interface)); memcpy(&HPMHooks.source.cmdline, cmdline, sizeof(struct cmdline_interface)); diff --git a/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc index 88e4f51dd..3e63de124 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.HPMHooksCore.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct { struct HPMHookPoint *HP_HCache_init_pre; struct HPMHookPoint *HP_HCache_init_post; diff --git a/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc index a558b16c5..cd846840b 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.HookingPoints.inc @@ -1,5 +1,6 @@ /** * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules * * Copyright (C) 2013-2016 Hercules Dev Team * @@ -22,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct HookingPointData HookingPoints[] = { /* HCache_interface */ { HP_POP(HCache->init, HP_HCache_init) }, diff --git a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc index 91909b819..23e2e2c90 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.Hooks.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + /* HCache_interface */ void HP_HCache_init(void) { int hIndex = 0; @@ -54,11 +56,11 @@ bool HP_HCache_check(const char *file) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_HCache_check_pre ) { - bool (*preHookFunc) (const char *file); + bool (*preHookFunc) (const char **file); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; - retVal___ = preHookFunc(file); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -81,11 +83,11 @@ FILE* HP_HCache_open(const char *file, const char *opt) { int hIndex = 0; FILE* retVal___ = NULL; if( HPMHooks.count.HP_HCache_open_pre ) { - FILE* (*preHookFunc) (const char *file, const char *opt); + FILE* (*preHookFunc) (const char **file, const char **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; - retVal___ = preHookFunc(file, opt); + retVal___ = preHookFunc(&file, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -161,11 +163,11 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_add_pre ) { - bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*preHookFunc) (unsigned int *pluginID, const char **name, char *shortname, CmdlineExecFunc *func, const char **help, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; - retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + retVal___ = preHookFunc(&pluginID, &name, &shortname, &func, &help, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -176,10 +178,10 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); } if( HPMHooks.count.HP_cmdline_arg_add_post ) { - bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*postHookFunc) (bool retVal___, unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + retVal___ = postHookFunc(retVal___, pluginID, name, shortname, func, help, options); } } return retVal___; @@ -188,11 +190,11 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_cmdline_exec_pre ) { - int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + int (*preHookFunc) (int *argc, char ***argv, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; - retVal___ = preHookFunc(&argc, argv, &options); + retVal___ = preHookFunc(&argc, &argv, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -203,10 +205,10 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); } if( HPMHooks.count.HP_cmdline_exec_post ) { - int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + int (*postHookFunc) (int retVal___, int argc, char **argv, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &argc, argv, &options); + retVal___ = postHookFunc(retVal___, argc, argv, options); } } return retVal___; @@ -215,11 +217,11 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { - bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + bool (*preHookFunc) (const char **name, int *current_arg, int *argc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; - retVal___ = preHookFunc(name, ¤t_arg, &argc); + retVal___ = preHookFunc(&name, ¤t_arg, &argc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -230,10 +232,10 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); } if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { - bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + bool (*postHookFunc) (bool retVal___, const char *name, int current_arg, int argc); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + retVal___ = postHookFunc(retVal___, name, current_arg, argc); } } return retVal___; @@ -242,11 +244,11 @@ const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_cmdline_arg_source_pre ) { - const char* (*preHookFunc) (struct CmdlineArgData *arg); + const char* (*preHookFunc) (struct CmdlineArgData **arg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; - retVal___ = preHookFunc(arg); + retVal___ = preHookFunc(&arg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -417,10 +419,10 @@ enum DBOptions HP_DB_fix_options(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.fix_options(type, options); } if( HPMHooks.count.HP_DB_fix_options_post ) { - enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType *type, enum DBOptions *options); + enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -444,10 +446,10 @@ DBComparator HP_DB_default_cmp(enum DBType type) { retVal___ = HPMHooks.source.DB.default_cmp(type); } if( HPMHooks.count.HP_DB_default_cmp_post ) { - DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType *type); + DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -471,10 +473,10 @@ DBHasher HP_DB_default_hash(enum DBType type) { retVal___ = HPMHooks.source.DB.default_hash(type); } if( HPMHooks.count.HP_DB_default_hash_post ) { - DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType *type); + DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -498,10 +500,10 @@ DBReleaser HP_DB_default_release(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.default_release(type, options); } if( HPMHooks.count.HP_DB_default_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType *type, enum DBOptions *options); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -525,10 +527,10 @@ DBReleaser HP_DB_custom_release(enum DBReleaseOption which) { retVal___ = HPMHooks.source.DB.custom_release(which); } if( HPMHooks.count.HP_DB_custom_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption *which); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption which); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &which); + retVal___ = postHookFunc(retVal___, which); } } return retVal___; @@ -537,11 +539,11 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT int hIndex = 0; struct DBMap* retVal___ = NULL; if( HPMHooks.count.HP_DB_alloc_pre ) { - struct DBMap* (*preHookFunc) (const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*preHookFunc) (const char **file, const char **func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; - retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + retVal___ = preHookFunc(&file, &func, &line, &type, &options, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -552,18 +554,17 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); } if( HPMHooks.count.HP_DB_alloc_post ) { - struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + retVal___ = postHookFunc(retVal___, file, func, line, type, options, maxlen); } } return retVal___; } union DBKey HP_DB_i2key(int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2key_pre ) { union DBKey (*preHookFunc) (int *key); *HPMforce_return = false; @@ -580,18 +581,17 @@ union DBKey HP_DB_i2key(int key) { retVal___ = HPMHooks.source.DB.i2key(key); } if( HPMHooks.count.HP_DB_i2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui2key(unsigned int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2key_pre ) { union DBKey (*preHookFunc) (unsigned int *key); *HPMforce_return = false; @@ -608,24 +608,23 @@ union DBKey HP_DB_ui2key(unsigned int key) { retVal___ = HPMHooks.source.DB.ui2key(key); } if( HPMHooks.count.HP_DB_ui2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_str2key(const char *key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_str2key_pre ) { - union DBKey (*preHookFunc) (const char *key); + union DBKey (*preHookFunc) (const char **key); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; - retVal___ = preHookFunc(key); + retVal___ = preHookFunc(&key); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -646,8 +645,7 @@ union DBKey HP_DB_str2key(const char *key) { } union DBKey HP_DB_i642key(int64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i642key_pre ) { union DBKey (*preHookFunc) (int64 *key); *HPMforce_return = false; @@ -664,18 +662,17 @@ union DBKey HP_DB_i642key(int64 key) { retVal___ = HPMHooks.source.DB.i642key(key); } if( HPMHooks.count.HP_DB_i642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui642key(uint64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui642key_pre ) { union DBKey (*preHookFunc) (uint64 *key); *HPMforce_return = false; @@ -692,18 +689,17 @@ union DBKey HP_DB_ui642key(uint64 key) { retVal___ = HPMHooks.source.DB.ui642key(key); } if( HPMHooks.count.HP_DB_ui642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, uint64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, uint64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } struct DBData HP_DB_i2data(int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2data_pre ) { struct DBData (*preHookFunc) (int *data); *HPMforce_return = false; @@ -720,18 +716,17 @@ struct DBData HP_DB_i2data(int data) { retVal___ = HPMHooks.source.DB.i2data(data); } if( HPMHooks.count.HP_DB_i2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ui2data(unsigned int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2data_pre ) { struct DBData (*preHookFunc) (unsigned int *data); *HPMforce_return = false; @@ -748,24 +743,23 @@ struct DBData HP_DB_ui2data(unsigned int data) { retVal___ = HPMHooks.source.DB.ui2data(data); } if( HPMHooks.count.HP_DB_ui2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ptr2data(void *data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ptr2data_pre ) { - struct DBData (*preHookFunc) (void *data); + struct DBData (*preHookFunc) (void **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -788,11 +782,11 @@ int HP_DB_data2i(struct DBData *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_DB_data2i_pre ) { - int (*preHookFunc) (struct DBData *data); + int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -815,11 +809,11 @@ unsigned int HP_DB_data2ui(struct DBData *data) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_DB_data2ui_pre ) { - unsigned int (*preHookFunc) (struct DBData *data); + unsigned int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -842,11 +836,11 @@ void* HP_DB_data2ptr(struct DBData *data) { int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_DB_data2ptr_pre ) { - void* (*preHookFunc) (struct DBData *data); + void* (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -988,10 +982,10 @@ void HP_lclif_connection_error(int fd, uint8 error) { HPMHooks.source.lclif.connection_error(fd, error); } if( HPMHooks.count.HP_lclif_connection_error_post ) { - void (*postHookFunc) (int *fd, uint8 *error); + void (*postHookFunc) (int fd, uint8 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_connection_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_connection_error_post[hIndex].func; - postHookFunc(&fd, &error); + postHookFunc(fd, error); } } return; @@ -1000,11 +994,11 @@ bool HP_lclif_server_list(struct login_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_lclif_server_list_pre ) { - bool (*preHookFunc) (struct login_session_data *sd); + bool (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_server_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_server_list_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1041,10 +1035,10 @@ void HP_lclif_auth_failed(int fd, time_t ban, uint32 error) { HPMHooks.source.lclif.auth_failed(fd, ban, error); } if( HPMHooks.count.HP_lclif_auth_failed_post ) { - void (*postHookFunc) (int *fd, time_t *ban, uint32 *error); + void (*postHookFunc) (int fd, time_t ban, uint32 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_auth_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_auth_failed_post[hIndex].func; - postHookFunc(&fd, &ban, &error); + postHookFunc(fd, ban, error); } } return; @@ -1067,10 +1061,10 @@ void HP_lclif_login_error(int fd, uint8 error) { HPMHooks.source.lclif.login_error(fd, error); } if( HPMHooks.count.HP_lclif_login_error_post ) { - void (*postHookFunc) (int *fd, uint8 *error); + void (*postHookFunc) (int fd, uint8 error); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_login_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_login_error_post[hIndex].func; - postHookFunc(&fd, &error); + postHookFunc(fd, error); } } return; @@ -1078,11 +1072,11 @@ void HP_lclif_login_error(int fd, uint8 error) { void HP_lclif_coding_key(int fd, struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_lclif_coding_key_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd); + void (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_coding_key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_coding_key_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1093,10 +1087,10 @@ void HP_lclif_coding_key(int fd, struct login_session_data *sd) { HPMHooks.source.lclif.coding_key(fd, sd); } if( HPMHooks.count.HP_lclif_coding_key_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd); + void (*postHookFunc) (int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_coding_key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_coding_key_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -1120,10 +1114,10 @@ const struct login_packet_db* HP_lclif_packet(int16 packet_id) { retVal___ = HPMHooks.source.lclif.packet(packet_id); } if( HPMHooks.count.HP_lclif_packet_post ) { - const struct login_packet_db* (*postHookFunc) (const struct login_packet_db* retVal___, int16 *packet_id); + const struct login_packet_db* (*postHookFunc) (const struct login_packet_db* retVal___, int16 packet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &packet_id); + retVal___ = postHookFunc(retVal___, packet_id); } } return retVal___; @@ -1132,11 +1126,11 @@ enum parsefunc_rcode HP_lclif_parse_packet(const struct login_packet_db *lpd, in int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_lclif_parse_packet_pre ) { - enum parsefunc_rcode (*preHookFunc) (const struct login_packet_db *lpd, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (const struct login_packet_db **lpd, int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_packet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_lclif_parse_packet_pre[hIndex].func; - retVal___ = preHookFunc(lpd, &fd, sd); + retVal___ = preHookFunc(&lpd, &fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1147,10 +1141,10 @@ enum parsefunc_rcode HP_lclif_parse_packet(const struct login_packet_db *lpd, in retVal___ = HPMHooks.source.lclif.parse_packet(lpd, fd, sd); } if( HPMHooks.count.HP_lclif_parse_packet_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, const struct login_packet_db *lpd, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, const struct login_packet_db *lpd, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_parse_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, lpd, &fd, sd); + retVal___ = postHookFunc(retVal___, lpd, fd, sd); } } return retVal___; @@ -1174,10 +1168,10 @@ int HP_lclif_parse(int fd) { retVal___ = HPMHooks.source.lclif.parse(fd); } if( HPMHooks.count.HP_lclif_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_lclif_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_lclif_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -1213,11 +1207,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_sub(int fd, struct login_session_data int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_sub_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_sub_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1228,10 +1222,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_sub(int fd, struct login_session_data retVal___ = HPMHooks.source.PRIV__lclif.parse_sub(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_sub_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1240,11 +1234,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED(int fd, struct int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1255,10 +1249,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED(int fd, struct retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_CONNECT_INFO_CHANGED(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CONNECT_INFO_CHANGED_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1267,11 +1261,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_EXE_HASHCHECK(int fd, struct login_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1282,10 +1276,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_EXE_HASHCHECK(int fd, struct login_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_EXE_HASHCHECK(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_EXE_HASHCHECK_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1294,11 +1288,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN(int fd, struct login_session_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1309,10 +1303,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN(int fd, struct login_session_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1321,11 +1315,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN2(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN2_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1336,10 +1330,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN2(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN2(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1348,11 +1342,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN3(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN3_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1363,10 +1357,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN3(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN3(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN3_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN3_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1375,11 +1369,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN4(int fd, struct login_session int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN4_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1390,10 +1384,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN4(int fd, struct login_session retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN4(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN4_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN4_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1402,11 +1396,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_PCBANG(int fd, struct login_s int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1417,10 +1411,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_PCBANG(int fd, struct login_s retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN_PCBANG(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_PCBANG_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1429,11 +1423,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_HAN(int fd, struct login_sess int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_HAN_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1444,10 +1438,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_LOGIN_HAN(int fd, struct login_sess retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_LOGIN_HAN(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_LOGIN_HAN_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1456,11 +1450,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ(int fd, struct login_ int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1471,10 +1465,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ(int fd, struct login_ retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_SSO_LOGIN_REQ(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_SSO_LOGIN_REQ_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1483,11 +1477,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_REQ_HASH(int fd, struct login_sessi int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_REQ_HASH_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1498,10 +1492,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_REQ_HASH(int fd, struct login_sessi retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_REQ_HASH(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_REQ_HASH_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_REQ_HASH_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1510,11 +1504,11 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT(int fd, struct lo int hIndex = 0; enum parsefunc_rcode retVal___ = PACKET_UNKNOWN; if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre ) { - enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1525,10 +1519,10 @@ enum parsefunc_rcode HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT(int fd, struct lo retVal___ = HPMHooks.source.PRIV__lclif.parse_CA_CHARSERVERCONNECT(fd, sd); } if( HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post ) { - enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int *fd, struct login_session_data *sd); + enum parsefunc_rcode (*postHookFunc) (enum parsefunc_rcode retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_PRIV__lclif_parse_CA_CHARSERVERCONNECT_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -1538,11 +1532,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_pre ) { - int (*preHookFunc) (struct config_t *config, FILE *stream); + int (*preHookFunc) (struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; - retVal___ = preHookFunc(config, stream); + retVal___ = preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1564,11 +1558,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { void HP_libconfig_write(const struct config_t *config, FILE *stream) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_write_pre ) { - void (*preHookFunc) (const struct config_t *config, FILE *stream); + void (*preHookFunc) (const struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; - preHookFunc(config, stream); + preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1590,11 +1584,11 @@ void HP_libconfig_write(const struct config_t *config, FILE *stream) { void HP_libconfig_set_options(struct config_t *config, int options) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_options_pre ) { - void (*preHookFunc) (struct config_t *config, int *options); + void (*preHookFunc) (struct config_t **config, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_options_pre[hIndex].func; - preHookFunc(config, &options); + preHookFunc(&config, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1605,10 +1599,10 @@ void HP_libconfig_set_options(struct config_t *config, int options) { HPMHooks.source.libconfig.set_options(config, options); } if( HPMHooks.count.HP_libconfig_set_options_post ) { - void (*postHookFunc) (struct config_t *config, int *options); + void (*postHookFunc) (struct config_t *config, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_set_options_post[hIndex].func; - postHookFunc(config, &options); + postHookFunc(config, options); } } return; @@ -1617,11 +1611,11 @@ int HP_libconfig_get_options(const struct config_t *config) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_get_options_pre ) { - int (*preHookFunc) (const struct config_t *config); + int (*preHookFunc) (const struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_get_options_pre[hIndex].func; - retVal___ = preHookFunc(config); + retVal___ = preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1644,11 +1638,11 @@ int HP_libconfig_read_string(struct config_t *config, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_string_pre ) { - int (*preHookFunc) (struct config_t *config, const char *str); + int (*preHookFunc) (struct config_t **config, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; - retVal___ = preHookFunc(config, str); + retVal___ = preHookFunc(&config, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1671,11 +1665,11 @@ int HP_libconfig_read_file_src(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1698,11 +1692,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_write_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1724,11 +1718,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) (void *)) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { - void (*preHookFunc) (struct config_t *config, void ( *destructor ) (void *)); + void (*preHookFunc) (struct config_t **config, void ( **destructor ) (void *)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; - preHookFunc(config, destructor); + preHookFunc(&config, &destructor); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1750,11 +1744,11 @@ void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) ( void HP_libconfig_set_include_dir(struct config_t *config, const char *include_dir) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { - void (*preHookFunc) (struct config_t *config, const char *include_dir); + void (*preHookFunc) (struct config_t **config, const char **include_dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; - preHookFunc(config, include_dir); + preHookFunc(&config, &include_dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1776,11 +1770,11 @@ void HP_libconfig_set_include_dir(struct config_t *config, const char *include_d void HP_libconfig_init(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_init_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1802,11 +1796,11 @@ void HP_libconfig_init(struct config_t *config) { void HP_libconfig_destroy(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_destroy_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1829,11 +1823,11 @@ int HP_libconfig_setting_get_int(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1856,11 +1850,11 @@ long long HP_libconfig_setting_get_int64(const struct config_setting_t *setting) int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting); + long long (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1883,11 +1877,11 @@ double HP_libconfig_setting_get_float(const struct config_setting_t *setting) { int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting); + double (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1910,11 +1904,11 @@ int HP_libconfig_setting_get_bool(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1937,11 +1931,11 @@ const char* HP_libconfig_setting_get_string(const struct config_setting_t *setti int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting); + const char* (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1964,11 +1958,11 @@ struct config_setting_t* HP_libconfig_setting_lookup(struct config_setting_t *se int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1991,11 +1985,11 @@ int HP_libconfig_setting_lookup_int(const struct config_setting_t *setting, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2018,11 +2012,11 @@ int HP_libconfig_setting_lookup_int64(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, long long *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2045,11 +2039,11 @@ int HP_libconfig_setting_lookup_float(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, double *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2072,11 +2066,11 @@ int HP_libconfig_setting_lookup_bool(const struct config_setting_t *setting, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2099,11 +2093,11 @@ int HP_libconfig_setting_lookup_string(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, const char **value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2126,11 +2120,11 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2141,10 +2135,10 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2153,11 +2147,11 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, long long *value); + int (*preHookFunc) (struct config_setting_t **setting, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2168,10 +2162,10 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2180,11 +2174,11 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, double *value); + int (*preHookFunc) (struct config_setting_t **setting, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2195,10 +2189,10 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2207,11 +2201,11 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2222,10 +2216,10 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -2234,11 +2228,11 @@ int HP_libconfig_setting_set_string(struct config_setting_t *setting, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, const char *value); + int (*preHookFunc) (struct config_setting_t **setting, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2261,11 +2255,11 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, short *format); + int (*preHookFunc) (struct config_setting_t **setting, short *format); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; - retVal___ = preHookFunc(setting, &format); + retVal___ = preHookFunc(&setting, &format); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2276,10 +2270,10 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); } if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short *format); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short format); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &format); + retVal___ = postHookFunc(retVal___, setting, format); } } return retVal___; @@ -2288,11 +2282,11 @@ short HP_libconfig_setting_get_format(const struct config_setting_t *setting) { int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { - short (*preHookFunc) (const struct config_setting_t *setting); + short (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2315,11 +2309,11 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2330,10 +2324,10 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2342,11 +2336,11 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting, int *idx); + long long (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2357,10 +2351,10 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { - long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int *idx); + long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2369,11 +2363,11 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting, int *idx); + double (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2384,10 +2378,10 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { - double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int *idx); + double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2396,11 +2390,11 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2411,10 +2405,10 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2423,11 +2417,11 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting, int *idx); + const char* (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2438,10 +2432,10 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { - const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int *idx); + const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2450,11 +2444,11 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2465,10 +2459,10 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2477,11 +2471,11 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2492,10 +2486,10 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2504,11 +2498,11 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2519,10 +2513,10 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2531,11 +2525,11 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2546,10 +2540,10 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2558,11 +2552,11 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2573,10 +2567,10 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, const char *value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -2585,11 +2579,11 @@ int HP_libconfig_setting_index(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_index_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2612,11 +2606,11 @@ int HP_libconfig_setting_length(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_length_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2639,11 +2633,11 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2654,10 +2648,10 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -2666,11 +2660,11 @@ struct config_setting_t* HP_libconfig_setting_get_member(const struct config_set int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2693,11 +2687,11 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_add_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **parent, const char **name, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; - retVal___ = preHookFunc(parent, name, &type); + retVal___ = preHookFunc(&parent, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2708,10 +2702,10 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); } if( HPMHooks.count.HP_libconfig_setting_add_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, name, &type); + retVal___ = postHookFunc(retVal___, parent, name, type); } } return retVal___; @@ -2720,11 +2714,11 @@ int HP_libconfig_setting_remove(struct config_setting_t *parent, const char *nam int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const char *name); + int (*preHookFunc) (struct config_setting_t **parent, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; - retVal___ = preHookFunc(parent, name); + retVal___ = preHookFunc(&parent, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2747,11 +2741,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, unsigned int *idx); + int (*preHookFunc) (struct config_setting_t **parent, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; - retVal___ = preHookFunc(parent, &idx); + retVal___ = preHookFunc(&parent, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2762,10 +2756,10 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); } if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int *idx); + int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, &idx); + retVal___ = postHookFunc(retVal___, parent, idx); } } return retVal___; @@ -2773,11 +2767,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i void HP_libconfig_setting_set_hook(struct config_setting_t *setting, void *hook) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { - void (*preHookFunc) (struct config_setting_t *setting, void *hook); + void (*preHookFunc) (struct config_setting_t **setting, void **hook); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; - preHookFunc(setting, hook); + preHookFunc(&setting, &hook); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2800,11 +2794,11 @@ struct config_setting_t* HP_libconfig_lookup(const struct config_t *config, cons int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_t *config, const char *filepath); + struct config_setting_t* (*preHookFunc) (const struct config_t **config, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath); + retVal___ = preHookFunc(&config, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2827,11 +2821,11 @@ int HP_libconfig_lookup_int(const struct config_t *config, const char *filepath, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2854,11 +2848,11 @@ int HP_libconfig_lookup_int64(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, long long *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2881,11 +2875,11 @@ int HP_libconfig_lookup_float(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, double *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2908,11 +2902,11 @@ int HP_libconfig_lookup_bool(const struct config_t *config, const char *filepath int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2935,11 +2929,11 @@ int HP_libconfig_lookup_string(const struct config_t *config, const char *filepa int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, const char **value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2962,11 +2956,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_load_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *config_filename); + int (*preHookFunc) (struct config_t **config, const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_load_file_pre[hIndex].func; - retVal___ = preHookFunc(config, config_filename); + retVal___ = preHookFunc(&config, &config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2988,11 +2982,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3014,11 +3008,11 @@ void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const str void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3040,11 +3034,11 @@ void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struc void HP_libconfig_setting_copy_aggregate(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3067,11 +3061,11 @@ int HP_libconfig_setting_copy(struct config_setting_t *parent, const struct conf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + int (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; - retVal___ = preHookFunc(parent, src); + retVal___ = preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3094,11 +3088,11 @@ bool HP_libconfig_setting_get_bool_real(const struct config_setting_t *setting) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_libconfig_setting_get_bool_real_pre ) { - bool (*preHookFunc) (const struct config_setting_t *setting); + bool (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3121,11 +3115,11 @@ uint32 HP_libconfig_setting_get_uint32(const struct config_setting_t *setting) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint32_pre ) { - uint32 (*preHookFunc) (const struct config_setting_t *setting); + uint32 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3148,11 +3142,11 @@ uint16 HP_libconfig_setting_get_uint16(const struct config_setting_t *setting) { int hIndex = 0; uint16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint16_pre ) { - uint16 (*preHookFunc) (const struct config_setting_t *setting); + uint16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3175,11 +3169,11 @@ int16 HP_libconfig_setting_get_int16(const struct config_setting_t *setting) { int hIndex = 0; int16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int16_pre ) { - int16 (*preHookFunc) (const struct config_setting_t *setting); + int16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3202,11 +3196,11 @@ int HP_libconfig_setting_lookup_bool_real(const struct config_setting_t *setting int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, bool *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, bool **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3229,11 +3223,11 @@ int HP_libconfig_setting_lookup_uint32(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint32 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint32 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3256,11 +3250,11 @@ int HP_libconfig_setting_lookup_uint16(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3283,11 +3277,11 @@ int HP_libconfig_setting_lookup_int16(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3310,11 +3304,11 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, out, &out_size); + retVal___ = preHookFunc(&setting, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3325,10 +3319,10 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se retVal___ = HPMHooks.source.libconfig.setting_lookup_mutable_string(setting, name, out, out_size); } if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, name, out, &out_size); + retVal___ = postHookFunc(retVal___, setting, name, out, out_size); } } return retVal___; @@ -3337,11 +3331,11 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_t **config, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(config, name, out, &out_size); + retVal___ = preHookFunc(&config, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3352,10 +3346,10 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char retVal___ = HPMHooks.source.libconfig.lookup_mutable_string(config, name, out, out_size); } if( HPMHooks.count.HP_libconfig_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, config, name, out, &out_size); + retVal___ = postHookFunc(retVal___, config, name, out, out_size); } } return retVal___; @@ -3365,11 +3359,11 @@ int HP_login_mmo_auth(struct login_session_data *sd, bool isServer) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_mmo_auth_pre ) { - int (*preHookFunc) (struct login_session_data *sd, bool *isServer); + int (*preHookFunc) (struct login_session_data **sd, bool *isServer); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_mmo_auth_pre[hIndex].func; - retVal___ = preHookFunc(sd, &isServer); + retVal___ = preHookFunc(&sd, &isServer); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3380,10 +3374,10 @@ int HP_login_mmo_auth(struct login_session_data *sd, bool isServer) { retVal___ = HPMHooks.source.login.mmo_auth(sd, isServer); } if( HPMHooks.count.HP_login_mmo_auth_post ) { - int (*postHookFunc) (int retVal___, struct login_session_data *sd, bool *isServer); + int (*postHookFunc) (int retVal___, struct login_session_data *sd, bool isServer); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_mmo_auth_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &isServer); + retVal___ = postHookFunc(retVal___, sd, isServer); } } return retVal___; @@ -3392,11 +3386,11 @@ int HP_login_mmo_auth_new(const char *userid, const char *pass, const char sex, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_mmo_auth_new_pre ) { - int (*preHookFunc) (const char *userid, const char *pass, const char *sex, const char *last_ip); + int (*preHookFunc) (const char **userid, const char **pass, const char *sex, const char **last_ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_new_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_mmo_auth_new_pre[hIndex].func; - retVal___ = preHookFunc(userid, pass, &sex, last_ip); + retVal___ = preHookFunc(&userid, &pass, &sex, &last_ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3407,10 +3401,10 @@ int HP_login_mmo_auth_new(const char *userid, const char *pass, const char sex, retVal___ = HPMHooks.source.login.mmo_auth_new(userid, pass, sex, last_ip); } if( HPMHooks.count.HP_login_mmo_auth_new_post ) { - int (*postHookFunc) (int retVal___, const char *userid, const char *pass, const char *sex, const char *last_ip); + int (*postHookFunc) (int retVal___, const char *userid, const char *pass, const char sex, const char *last_ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_mmo_auth_new_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_mmo_auth_new_post[hIndex].func; - retVal___ = postHookFunc(retVal___, userid, pass, &sex, last_ip); + retVal___ = postHookFunc(retVal___, userid, pass, sex, last_ip); } } return retVal___; @@ -3434,18 +3428,17 @@ int HP_login_waiting_disconnect_timer(int tid, int64 tick, int id, intptr_t data retVal___ = HPMHooks.source.login.waiting_disconnect_timer(tid, tick, id, data); } if( HPMHooks.count.HP_login_waiting_disconnect_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_waiting_disconnect_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_waiting_disconnect_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; } struct DBData HP_login_create_online_user(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_login_create_online_user_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -3466,11 +3459,11 @@ struct DBData HP_login_create_online_user(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_login_create_online_user_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_create_online_user_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_login_create_online_user_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -3495,10 +3488,10 @@ struct online_login_data* HP_login_add_online_user(int char_server, int account_ retVal___ = HPMHooks.source.login.add_online_user(char_server, account_id); } if( HPMHooks.count.HP_login_add_online_user_post ) { - struct online_login_data* (*postHookFunc) (struct online_login_data* retVal___, int *char_server, int *account_id); + struct online_login_data* (*postHookFunc) (struct online_login_data* retVal___, int char_server, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_add_online_user_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_add_online_user_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_server, &account_id); + retVal___ = postHookFunc(retVal___, char_server, account_id); } } return retVal___; @@ -3521,10 +3514,10 @@ void HP_login_remove_online_user(int account_id) { HPMHooks.source.login.remove_online_user(account_id); } if( HPMHooks.count.HP_login_remove_online_user_post ) { - void (*postHookFunc) (int *account_id); + void (*postHookFunc) (int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_remove_online_user_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_remove_online_user_post[hIndex].func; - postHookFunc(&account_id); + postHookFunc(account_id); } } return; @@ -3533,12 +3526,12 @@ int HP_login_online_db_setoffline(union DBKey key, struct DBData *data, va_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_online_db_setoffline_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_db_setoffline_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_login_online_db_setoffline_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3552,11 +3545,11 @@ int HP_login_online_db_setoffline(union DBKey key, struct DBData *data, va_list va_end(ap___copy); } if( HPMHooks.count.HP_login_online_db_setoffline_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_db_setoffline_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_login_online_db_setoffline_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3566,12 +3559,12 @@ int HP_login_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_li int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_online_data_cleanup_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_login_online_data_cleanup_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3585,11 +3578,11 @@ int HP_login_online_data_cleanup_sub(union DBKey key, struct DBData *data, va_li va_end(ap___copy); } if( HPMHooks.count.HP_login_online_data_cleanup_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_login_online_data_cleanup_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3614,10 +3607,10 @@ int HP_login_online_data_cleanup(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.login.online_data_cleanup(tid, tick, id, data); } if( HPMHooks.count.HP_login_online_data_cleanup_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_online_data_cleanup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_online_data_cleanup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3641,10 +3634,10 @@ int HP_login_sync_ip_addresses(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.login.sync_ip_addresses(tid, tick, id, data); } if( HPMHooks.count.HP_login_sync_ip_addresses_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_sync_ip_addresses_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_sync_ip_addresses_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3653,11 +3646,11 @@ bool HP_login_check_encrypted(const char *str1, const char *str2, const char *pa int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_check_encrypted_pre ) { - bool (*preHookFunc) (const char *str1, const char *str2, const char *passwd); + bool (*preHookFunc) (const char **str1, const char **str2, const char **passwd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_encrypted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_check_encrypted_pre[hIndex].func; - retVal___ = preHookFunc(str1, str2, passwd); + retVal___ = preHookFunc(&str1, &str2, &passwd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3680,11 +3673,11 @@ bool HP_login_check_password(const char *md5key, int passwdenc, const char *pass int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_check_password_pre ) { - bool (*preHookFunc) (const char *md5key, int *passwdenc, const char *passwd, const char *refpass); + bool (*preHookFunc) (const char **md5key, int *passwdenc, const char **passwd, const char **refpass); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_password_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_check_password_pre[hIndex].func; - retVal___ = preHookFunc(md5key, &passwdenc, passwd, refpass); + retVal___ = preHookFunc(&md5key, &passwdenc, &passwd, &refpass); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3695,10 +3688,10 @@ bool HP_login_check_password(const char *md5key, int passwdenc, const char *pass retVal___ = HPMHooks.source.login.check_password(md5key, passwdenc, passwd, refpass); } if( HPMHooks.count.HP_login_check_password_post ) { - bool (*postHookFunc) (bool retVal___, const char *md5key, int *passwdenc, const char *passwd, const char *refpass); + bool (*postHookFunc) (bool retVal___, const char *md5key, int passwdenc, const char *passwd, const char *refpass); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_check_password_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_check_password_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md5key, &passwdenc, passwd, refpass); + retVal___ = postHookFunc(retVal___, md5key, passwdenc, passwd, refpass); } } return retVal___; @@ -3722,10 +3715,10 @@ uint32 HP_login_lan_subnet_check(uint32 ip) { retVal___ = HPMHooks.source.login.lan_subnet_check(ip); } if( HPMHooks.count.HP_login_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip); + uint32 (*postHookFunc) (uint32 retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_lan_subnet_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_lan_subnet_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -3733,11 +3726,11 @@ uint32 HP_login_lan_subnet_check(uint32 ip) { void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int u_group, int map_fd, struct mmo_account *acc) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_accinfo_pre ) { - void (*preHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account *acc); + void (*preHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account **acc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_accinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_accinfo_pre[hIndex].func; - preHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, acc); + preHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, &acc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3748,10 +3741,10 @@ void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int HPMHooks.source.login.fromchar_accinfo(fd, account_id, u_fd, u_aid, u_group, map_fd, acc); } if( HPMHooks.count.HP_login_fromchar_accinfo_post ) { - void (*postHookFunc) (int *fd, int *account_id, int *u_fd, int *u_aid, int *u_group, int *map_fd, struct mmo_account *acc); + void (*postHookFunc) (int fd, int account_id, int u_fd, int u_aid, int u_group, int map_fd, struct mmo_account *acc); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_accinfo_post[hIndex].func; - postHookFunc(&fd, &account_id, &u_fd, &u_aid, &u_group, &map_fd, acc); + postHookFunc(fd, account_id, u_fd, u_aid, u_group, map_fd, acc); } } return; @@ -3759,11 +3752,11 @@ void HP_login_fromchar_accinfo(int fd, int account_id, int u_fd, int u_aid, int void HP_login_fromchar_account(int fd, int account_id, struct mmo_account *acc) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_account_pre ) { - void (*preHookFunc) (int *fd, int *account_id, struct mmo_account *acc); + void (*preHookFunc) (int *fd, int *account_id, struct mmo_account **acc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_account_pre[hIndex].func; - preHookFunc(&fd, &account_id, acc); + preHookFunc(&fd, &account_id, &acc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3774,10 +3767,10 @@ void HP_login_fromchar_account(int fd, int account_id, struct mmo_account *acc) HPMHooks.source.login.fromchar_account(fd, account_id, acc); } if( HPMHooks.count.HP_login_fromchar_account_post ) { - void (*postHookFunc) (int *fd, int *account_id, struct mmo_account *acc); + void (*postHookFunc) (int fd, int account_id, struct mmo_account *acc); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_account_post[hIndex].func; - postHookFunc(&fd, &account_id, acc); + postHookFunc(fd, account_id, acc); } } return; @@ -3800,10 +3793,10 @@ void HP_login_fromchar_account_update_other(int account_id, unsigned int state) HPMHooks.source.login.fromchar_account_update_other(account_id, state); } if( HPMHooks.count.HP_login_fromchar_account_update_other_post ) { - void (*postHookFunc) (int *account_id, unsigned int *state); + void (*postHookFunc) (int account_id, unsigned int state); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_account_update_other_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_account_update_other_post[hIndex].func; - postHookFunc(&account_id, &state); + postHookFunc(account_id, state); } } return; @@ -3811,11 +3804,11 @@ void HP_login_fromchar_account_update_other(int account_id, unsigned int state) void HP_login_fromchar_auth_ack(int fd, int account_id, uint32 login_id1, uint32 login_id2, uint8 sex, int request_id, struct login_auth_node *node) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_auth_ack_pre ) { - void (*preHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node *node); + void (*preHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node **node); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_auth_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_auth_ack_pre[hIndex].func; - preHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, node); + preHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, &node); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3826,10 +3819,10 @@ void HP_login_fromchar_auth_ack(int fd, int account_id, uint32 login_id1, uint32 HPMHooks.source.login.fromchar_auth_ack(fd, account_id, login_id1, login_id2, sex, request_id, node); } if( HPMHooks.count.HP_login_fromchar_auth_ack_post ) { - void (*postHookFunc) (int *fd, int *account_id, uint32 *login_id1, uint32 *login_id2, uint8 *sex, int *request_id, struct login_auth_node *node); + void (*postHookFunc) (int fd, int account_id, uint32 login_id1, uint32 login_id2, uint8 sex, int request_id, struct login_auth_node *node); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_auth_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_auth_ack_post[hIndex].func; - postHookFunc(&fd, &account_id, &login_id1, &login_id2, &sex, &request_id, node); + postHookFunc(fd, account_id, login_id1, login_id2, sex, request_id, node); } } return; @@ -3852,10 +3845,10 @@ void HP_login_fromchar_ban(int account_id, time_t timestamp) { HPMHooks.source.login.fromchar_ban(account_id, timestamp); } if( HPMHooks.count.HP_login_fromchar_ban_post ) { - void (*postHookFunc) (int *account_id, time_t *timestamp); + void (*postHookFunc) (int account_id, time_t timestamp); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_ban_post[hIndex].func; - postHookFunc(&account_id, ×tamp); + postHookFunc(account_id, timestamp); } } return; @@ -3878,10 +3871,10 @@ void HP_login_fromchar_change_sex_other(int account_id, char sex) { HPMHooks.source.login.fromchar_change_sex_other(account_id, sex); } if( HPMHooks.count.HP_login_fromchar_change_sex_other_post ) { - void (*postHookFunc) (int *account_id, char *sex); + void (*postHookFunc) (int account_id, char sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_change_sex_other_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_change_sex_other_post[hIndex].func; - postHookFunc(&account_id, &sex); + postHookFunc(account_id, sex); } } return; @@ -3904,10 +3897,10 @@ void HP_login_fromchar_pong(int fd) { HPMHooks.source.login.fromchar_pong(fd); } if( HPMHooks.count.HP_login_fromchar_pong_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_pong_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_pong_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -3915,11 +3908,11 @@ void HP_login_fromchar_pong(int fd) { void HP_login_fromchar_parse_auth(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_auth_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_auth_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3930,10 +3923,10 @@ void HP_login_fromchar_parse_auth(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_auth(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_auth_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_auth_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -3956,10 +3949,10 @@ void HP_login_fromchar_parse_update_users(int fd, int id) { HPMHooks.source.login.fromchar_parse_update_users(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_update_users_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_update_users_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_update_users_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -3967,11 +3960,11 @@ void HP_login_fromchar_parse_update_users(int fd, int id) { void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_request_change_email_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_change_email_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_change_email_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3982,10 +3975,10 @@ void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip HPMHooks.source.login.fromchar_parse_request_change_email(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_request_change_email_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_change_email_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_change_email_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -3993,11 +3986,11 @@ void HP_login_fromchar_parse_request_change_email(int fd, int id, const char *ip void HP_login_fromchar_parse_account_data(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_data_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_data_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4008,10 +4001,10 @@ void HP_login_fromchar_parse_account_data(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_data(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_data_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_data_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4034,10 +4027,10 @@ void HP_login_fromchar_parse_ping(int fd) { HPMHooks.source.login.fromchar_parse_ping(fd); } if( HPMHooks.count.HP_login_fromchar_parse_ping_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ping_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_ping_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4045,11 +4038,11 @@ void HP_login_fromchar_parse_ping(int fd) { void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_change_email_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_email_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_email_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4060,10 +4053,10 @@ void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_change_email(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_change_email_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_email_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_email_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4071,11 +4064,11 @@ void HP_login_fromchar_parse_change_email(int fd, int id, const char *ip) { void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_update_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_update_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4086,10 +4079,10 @@ void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_update(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_update_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_update_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4097,11 +4090,11 @@ void HP_login_fromchar_parse_account_update(int fd, int id, const char *ip) { void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_ban_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_ban_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4112,10 +4105,10 @@ void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_ban(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_ban_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_ban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_ban_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4123,11 +4116,11 @@ void HP_login_fromchar_parse_ban(int fd, int id, const char *ip) { void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_change_sex_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_sex_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_sex_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4138,10 +4131,10 @@ void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_change_sex(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_change_sex_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_sex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_sex_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4149,11 +4142,11 @@ void HP_login_fromchar_parse_change_sex(int fd, int id, const char *ip) { void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_account_reg2_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_reg2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_reg2_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4164,10 +4157,10 @@ void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_account_reg2(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_account_reg2_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_reg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_reg2_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4175,11 +4168,11 @@ void HP_login_fromchar_parse_account_reg2(int fd, int id, const char *ip) { void HP_login_fromchar_parse_unban(int fd, int id, const char *ip) { int hIndex = 0; if( HPMHooks.count.HP_login_fromchar_parse_unban_pre ) { - void (*preHookFunc) (int *fd, int *id, const char *ip); + void (*preHookFunc) (int *fd, int *id, const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_unban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_fromchar_parse_unban_pre[hIndex].func; - preHookFunc(&fd, &id, ip); + preHookFunc(&fd, &id, &ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4190,10 +4183,10 @@ void HP_login_fromchar_parse_unban(int fd, int id, const char *ip) { HPMHooks.source.login.fromchar_parse_unban(fd, id, ip); } if( HPMHooks.count.HP_login_fromchar_parse_unban_post ) { - void (*postHookFunc) (int *fd, int *id, const char *ip); + void (*postHookFunc) (int fd, int id, const char *ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_unban_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_unban_post[hIndex].func; - postHookFunc(&fd, &id, ip); + postHookFunc(fd, id, ip); } } return; @@ -4216,10 +4209,10 @@ void HP_login_fromchar_parse_account_online(int fd, int id) { HPMHooks.source.login.fromchar_parse_account_online(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_account_online_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_online_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_online_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4242,10 +4235,10 @@ void HP_login_fromchar_parse_account_offline(int fd) { HPMHooks.source.login.fromchar_parse_account_offline(fd); } if( HPMHooks.count.HP_login_fromchar_parse_account_offline_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_account_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_account_offline_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4268,10 +4261,10 @@ void HP_login_fromchar_parse_online_accounts(int fd, int id) { HPMHooks.source.login.fromchar_parse_online_accounts(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_online_accounts_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_online_accounts_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_online_accounts_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4294,10 +4287,10 @@ void HP_login_fromchar_parse_request_account_reg2(int fd) { HPMHooks.source.login.fromchar_parse_request_account_reg2(fd); } if( HPMHooks.count.HP_login_fromchar_parse_request_account_reg2_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_request_account_reg2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_request_account_reg2_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4320,10 +4313,10 @@ void HP_login_fromchar_parse_update_wan_ip(int fd, int id) { HPMHooks.source.login.fromchar_parse_update_wan_ip(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_update_wan_ip_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_update_wan_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_update_wan_ip_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4346,10 +4339,10 @@ void HP_login_fromchar_parse_all_offline(int fd, int id) { HPMHooks.source.login.fromchar_parse_all_offline(fd, id); } if( HPMHooks.count.HP_login_fromchar_parse_all_offline_post ) { - void (*postHookFunc) (int *fd, int *id); + void (*postHookFunc) (int fd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_all_offline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_all_offline_post[hIndex].func; - postHookFunc(&fd, &id); + postHookFunc(fd, id); } } return; @@ -4372,10 +4365,10 @@ void HP_login_fromchar_parse_change_pincode(int fd) { HPMHooks.source.login.fromchar_parse_change_pincode(fd); } if( HPMHooks.count.HP_login_fromchar_parse_change_pincode_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_change_pincode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_change_pincode_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4399,10 +4392,10 @@ bool HP_login_fromchar_parse_wrong_pincode(int fd) { retVal___ = HPMHooks.source.login.fromchar_parse_wrong_pincode(fd); } if( HPMHooks.count.HP_login_fromchar_parse_wrong_pincode_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_wrong_pincode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_wrong_pincode_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -4425,10 +4418,10 @@ void HP_login_fromchar_parse_accinfo(int fd) { HPMHooks.source.login.fromchar_parse_accinfo(fd); } if( HPMHooks.count.HP_login_fromchar_parse_accinfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_fromchar_parse_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_fromchar_parse_accinfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4452,10 +4445,10 @@ int HP_login_parse_fromchar(int fd) { retVal___ = HPMHooks.source.login.parse_fromchar(fd); } if( HPMHooks.count.HP_login_parse_fromchar_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_fromchar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_parse_fromchar_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -4463,11 +4456,11 @@ int HP_login_parse_fromchar(int fd) { void HP_login_kick(struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_login_kick_pre ) { - void (*preHookFunc) (struct login_session_data *sd); + void (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_kick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_kick_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4489,11 +4482,11 @@ void HP_login_kick(struct login_session_data *sd) { void HP_login_auth_ok(struct login_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_login_auth_ok_pre ) { - void (*preHookFunc) (struct login_session_data *sd); + void (*preHookFunc) (struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_auth_ok_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4515,11 +4508,11 @@ void HP_login_auth_ok(struct login_session_data *sd) { void HP_login_auth_failed(struct login_session_data *sd, int result) { int hIndex = 0; if( HPMHooks.count.HP_login_auth_failed_pre ) { - void (*preHookFunc) (struct login_session_data *sd, int *result); + void (*preHookFunc) (struct login_session_data **sd, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_failed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_auth_failed_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4530,10 +4523,10 @@ void HP_login_auth_failed(struct login_session_data *sd, int result) { HPMHooks.source.login.auth_failed(sd, result); } if( HPMHooks.count.HP_login_auth_failed_post ) { - void (*postHookFunc) (struct login_session_data *sd, int *result); + void (*postHookFunc) (struct login_session_data *sd, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_auth_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_auth_failed_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -4542,11 +4535,11 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_login_client_login_pre ) { - bool (*preHookFunc) (int *fd, struct login_session_data *sd); + bool (*preHookFunc) (int *fd, struct login_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_client_login_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_client_login_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4557,10 +4550,10 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { retVal___ = HPMHooks.source.login.client_login(fd, sd); } if( HPMHooks.count.HP_login_client_login_post ) { - bool (*postHookFunc) (bool retVal___, int *fd, struct login_session_data *sd); + bool (*postHookFunc) (bool retVal___, int fd, struct login_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_client_login_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_client_login_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -4568,11 +4561,11 @@ bool HP_login_client_login(int fd, struct login_session_data *sd) { void HP_login_char_server_connection_status(int fd, struct login_session_data *sd, uint8 status) { int hIndex = 0; if( HPMHooks.count.HP_login_char_server_connection_status_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd, uint8 *status); + void (*preHookFunc) (int *fd, struct login_session_data **sd, uint8 *status); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_char_server_connection_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_char_server_connection_status_pre[hIndex].func; - preHookFunc(&fd, sd, &status); + preHookFunc(&fd, &sd, &status); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4583,10 +4576,10 @@ void HP_login_char_server_connection_status(int fd, struct login_session_data *s HPMHooks.source.login.char_server_connection_status(fd, sd, status); } if( HPMHooks.count.HP_login_char_server_connection_status_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd, uint8 *status); + void (*postHookFunc) (int fd, struct login_session_data *sd, uint8 status); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_char_server_connection_status_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_char_server_connection_status_post[hIndex].func; - postHookFunc(&fd, sd, &status); + postHookFunc(fd, sd, status); } } return; @@ -4594,11 +4587,11 @@ void HP_login_char_server_connection_status(int fd, struct login_session_data *s void HP_login_parse_request_connection(int fd, struct login_session_data *sd, const char *ip, uint32 ipl) { int hIndex = 0; if( HPMHooks.count.HP_login_parse_request_connection_pre ) { - void (*preHookFunc) (int *fd, struct login_session_data *sd, const char *ip, uint32 *ipl); + void (*preHookFunc) (int *fd, struct login_session_data **sd, const char **ip, uint32 *ipl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_request_connection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_parse_request_connection_pre[hIndex].func; - preHookFunc(&fd, sd, ip, &ipl); + preHookFunc(&fd, &sd, &ip, &ipl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4609,10 +4602,10 @@ void HP_login_parse_request_connection(int fd, struct login_session_data *sd, co HPMHooks.source.login.parse_request_connection(fd, sd, ip, ipl); } if( HPMHooks.count.HP_login_parse_request_connection_post ) { - void (*postHookFunc) (int *fd, struct login_session_data *sd, const char *ip, uint32 *ipl); + void (*postHookFunc) (int fd, struct login_session_data *sd, const char *ip, uint32 ipl); for(hIndex = 0; hIndex < HPMHooks.count.HP_login_parse_request_connection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_login_parse_request_connection_post[hIndex].func; - postHookFunc(&fd, sd, ip, &ipl); + postHookFunc(fd, sd, ip, ipl); } } return; @@ -4647,11 +4640,11 @@ int HP_login_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_login_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_login_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_login_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4727,11 +4720,11 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_malloc_pre ) { - void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; - retVal___ = preHookFunc(&size, file, &line, func); + retVal___ = preHookFunc(&size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4742,10 +4735,10 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); } if( HPMHooks.count.HP_iMalloc_malloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, size, file, line, func); } } return retVal___; @@ -4754,11 +4747,11 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_calloc_pre ) { - void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *num, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; - retVal___ = preHookFunc(&num, &size, file, &line, func); + retVal___ = preHookFunc(&num, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4769,10 +4762,10 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_calloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, num, size, file, line, func); } } return retVal___; @@ -4781,11 +4774,11 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_realloc_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4796,10 +4789,10 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_realloc_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4808,11 +4801,11 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4823,10 +4816,10 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_reallocz_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4835,11 +4828,11 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { - char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; - retVal___ = preHookFunc(p, file, &line, func); + retVal___ = preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4850,10 +4843,10 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrdup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, file, &line, func); + retVal___ = postHookFunc(retVal___, p, file, line, func); } } return retVal___; @@ -4862,11 +4855,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrndup_pre ) { - char* (*preHookFunc) (const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4877,10 +4870,10 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line retVal___ = HPMHooks.source.iMalloc.astrndup(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrndup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrndup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -4888,11 +4881,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { int hIndex = 0; if( HPMHooks.count.HP_iMalloc_free_pre ) { - void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + void (*preHookFunc) (void **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; - preHookFunc(p, file, &line, func); + preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4903,10 +4896,10 @@ void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { HPMHooks.source.iMalloc.free(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_free_post ) { - void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + void (*postHookFunc) (void *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; - postHookFunc(p, file, &line, func); + postHookFunc(p, file, line, func); } } return; @@ -4941,11 +4934,11 @@ bool HP_iMalloc_verify_ptr(void *ptr) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { - bool (*preHookFunc) (void *ptr); + bool (*preHookFunc) (void **ptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; - retVal___ = preHookFunc(ptr); + retVal___ = preHookFunc(&ptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5047,11 +5040,11 @@ void HP_iMalloc_init_messages(void) { void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { int hIndex = 0; if( HPMHooks.count.HP_nullpo_assert_report_pre ) { - void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*preHookFunc) (const char **file, int *line, const char **func, const char **targetname, const char **title); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; - preHookFunc(file, &line, func, targetname, title); + preHookFunc(&file, &line, &func, &targetname, &title); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5062,10 +5055,10 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); } if( HPMHooks.count.HP_nullpo_assert_report_post ) { - void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*postHookFunc) (const char *file, int line, const char *func, const char *targetname, const char *title); for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; - postHookFunc(file, &line, func, targetname, title); + postHookFunc(file, line, func, targetname, title); } } return; @@ -5153,12 +5146,12 @@ int HP_showmsg_showMessageV(const char *string, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { - int (*preHookFunc) (const char *string, va_list ap); + int (*preHookFunc) (const char **string, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; - retVal___ = preHookFunc(string, ap___copy); + retVal___ = preHookFunc(&string, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5254,10 +5247,10 @@ int HP_sockt_perform(int next) { retVal___ = HPMHooks.source.sockt.perform(next); } if( HPMHooks.count.HP_sockt_perform_post ) { - int (*postHookFunc) (int retVal___, int *next); + int (*postHookFunc) (int retVal___, int next); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &next); + retVal___ = postHookFunc(retVal___, next); } } return retVal___; @@ -5280,10 +5273,10 @@ void HP_sockt_datasync(int fd, bool send) { HPMHooks.source.sockt.datasync(fd, send); } if( HPMHooks.count.HP_sockt_datasync_post ) { - void (*postHookFunc) (int *fd, bool *send); + void (*postHookFunc) (int fd, bool send); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; - postHookFunc(&fd, &send); + postHookFunc(fd, send); } } return; @@ -5307,10 +5300,10 @@ int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); } if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port); + retVal___ = postHookFunc(retVal___, ip, port); } } return retVal___; @@ -5319,11 +5312,11 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_make_connection_pre ) { - int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; - retVal___ = preHookFunc(&ip, &port, opt); + retVal___ = preHookFunc(&ip, &port, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5334,10 +5327,10 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); } if( HPMHooks.count.HP_sockt_make_connection_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port, struct hSockOpt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port, opt); + retVal___ = postHookFunc(retVal___, ip, port, opt); } } return retVal___; @@ -5361,10 +5354,10 @@ int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_si retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); } if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + int (*postHookFunc) (int retVal___, int fd, unsigned int rfifo_size, unsigned int wfifo_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + retVal___ = postHookFunc(retVal___, fd, rfifo_size, wfifo_size); } } return retVal___; @@ -5388,10 +5381,10 @@ int HP_sockt_realloc_writefifo(int fd, size_t addition) { retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); } if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + int (*postHookFunc) (int retVal___, int fd, size_t addition); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &addition); + retVal___ = postHookFunc(retVal___, fd, addition); } } return retVal___; @@ -5415,10 +5408,10 @@ int HP_sockt_wfifoset(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); } if( HPMHooks.count.HP_sockt_wfifoset_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -5442,10 +5435,10 @@ int HP_sockt_rfifoskip(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); } if( HPMHooks.count.HP_sockt_rfifoskip_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -5468,10 +5461,10 @@ void HP_sockt_close(int fd) { HPMHooks.source.sockt.close(fd); } if( HPMHooks.count.HP_sockt_close_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5495,10 +5488,10 @@ bool HP_sockt_session_is_valid(int fd) { retVal___ = HPMHooks.source.sockt.session_is_valid(fd); } if( HPMHooks.count.HP_sockt_session_is_valid_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5522,10 +5515,10 @@ bool HP_sockt_session_is_active(int fd) { retVal___ = HPMHooks.source.sockt.session_is_active(fd); } if( HPMHooks.count.HP_sockt_session_is_active_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -5548,10 +5541,10 @@ void HP_sockt_flush(int fd) { HPMHooks.source.sockt.flush(fd); } if( HPMHooks.count.HP_sockt_flush_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5600,10 +5593,10 @@ void HP_sockt_set_nonblocking(int fd, unsigned long yes) { HPMHooks.source.sockt.set_nonblocking(fd, yes); } if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { - void (*postHookFunc) (int *fd, unsigned long *yes); + void (*postHookFunc) (int fd, unsigned long yes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; - postHookFunc(&fd, &yes); + postHookFunc(fd, yes); } } return; @@ -5626,10 +5619,10 @@ void HP_sockt_set_defaultparse(ParseFunc defaultparse) { HPMHooks.source.sockt.set_defaultparse(defaultparse); } if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { - void (*postHookFunc) (ParseFunc *defaultparse); + void (*postHookFunc) (ParseFunc defaultparse); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; - postHookFunc(&defaultparse); + postHookFunc(defaultparse); } } return; @@ -5638,11 +5631,11 @@ uint32 HP_sockt_host2ip(const char *hostname) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_host2ip_pre ) { - uint32 (*preHookFunc) (const char *hostname); + uint32 (*preHookFunc) (const char **hostname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; - retVal___ = preHookFunc(hostname); + retVal___ = preHookFunc(&hostname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5665,11 +5658,11 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sockt_ip2str_pre ) { - const char* (*preHookFunc) (uint32 *ip, char *ip_str); + const char* (*preHookFunc) (uint32 *ip, char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; - retVal___ = preHookFunc(&ip, ip_str); + retVal___ = preHookFunc(&ip, &ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5680,10 +5673,10 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); } if( HPMHooks.count.HP_sockt_ip2str_post ) { - const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + const char* (*postHookFunc) (const char* retVal___, uint32 ip, char *ip_str); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, ip_str); + retVal___ = postHookFunc(retVal___, ip, ip_str); } } return retVal___; @@ -5692,11 +5685,11 @@ uint32 HP_sockt_str2ip(const char *ip_str) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_str2ip_pre ) { - uint32 (*preHookFunc) (const char *ip_str); + uint32 (*preHookFunc) (const char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; - retVal___ = preHookFunc(ip_str); + retVal___ = preHookFunc(&ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5734,10 +5727,10 @@ uint16 HP_sockt_ntows(uint16 netshort) { retVal___ = HPMHooks.source.sockt.ntows(netshort); } if( HPMHooks.count.HP_sockt_ntows_post ) { - uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + uint16 (*postHookFunc) (uint16 retVal___, uint16 netshort); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &netshort); + retVal___ = postHookFunc(retVal___, netshort); } } return retVal___; @@ -5746,11 +5739,11 @@ int HP_sockt_getips(uint32 *ips, int max) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_getips_pre ) { - int (*preHookFunc) (uint32 *ips, int *max); + int (*preHookFunc) (uint32 **ips, int *max); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; - retVal___ = preHookFunc(ips, &max); + retVal___ = preHookFunc(&ips, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5761,10 +5754,10 @@ int HP_sockt_getips(uint32 *ips, int max) { retVal___ = HPMHooks.source.sockt.getips(ips, max); } if( HPMHooks.count.HP_sockt_getips_post ) { - int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + int (*postHookFunc) (int retVal___, uint32 *ips, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ips, &max); + retVal___ = postHookFunc(retVal___, ips, max); } } return retVal___; @@ -5787,10 +5780,10 @@ void HP_sockt_eof(int fd) { HPMHooks.source.sockt.eof(fd); } if( HPMHooks.count.HP_sockt_eof_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5799,11 +5792,11 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { - uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet **info); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; - retVal___ = preHookFunc(&ip, info); + retVal___ = preHookFunc(&ip, &info); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5814,10 +5807,10 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); } if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + uint32 (*postHookFunc) (uint32 retVal___, uint32 ip, struct s_subnet *info); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, info); + retVal___ = postHookFunc(retVal___, ip, info); } } return retVal___; @@ -5841,10 +5834,10 @@ bool HP_sockt_allowed_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); } if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -5868,10 +5861,10 @@ bool HP_sockt_trusted_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); } if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -5880,11 +5873,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname); + int (*preHookFunc) (struct config_setting_t **t, struct s_subnet_vector **list, const char **filename, const char **groupname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; - retVal___ = preHookFunc(t, list, filename, groupname); + retVal___ = preHookFunc(&t, &list, &filename, &groupname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5906,11 +5899,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec void HP_sockt_net_config_read(const char *filename) { int hIndex = 0; if( HPMHooks.count.HP_sockt_net_config_read_pre ) { - void (*preHookFunc) (const char *filename); + void (*preHookFunc) (const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; - preHookFunc(filename); + preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5934,11 +5927,11 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Connect_pre ) { - int (*preHookFunc) (struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*preHookFunc) (struct Sql **self, const char **user, const char **passwd, const char **host, uint16 *port, const char **db); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; - retVal___ = preHookFunc(self, user, passwd, host, &port, db); + retVal___ = preHookFunc(&self, &user, &passwd, &host, &port, &db); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5949,10 +5942,10 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); } if( HPMHooks.count.HP_SQL_Connect_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + retVal___ = postHookFunc(retVal___, self, user, passwd, host, port, db); } } return retVal___; @@ -5961,11 +5954,11 @@ int HP_SQL_GetTimeout(struct Sql *self, uint32 *out_timeout) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { - int (*preHookFunc) (struct Sql *self, uint32 *out_timeout); + int (*preHookFunc) (struct Sql **self, uint32 **out_timeout); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; - retVal___ = preHookFunc(self, out_timeout); + retVal___ = preHookFunc(&self, &out_timeout); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5988,11 +5981,11 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { - int (*preHookFunc) (struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*preHookFunc) (struct Sql **self, const char **table, char **out_buf, size_t *buf_len, char *sep); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; - retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + retVal___ = preHookFunc(&self, &table, &out_buf, &buf_len, &sep); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6003,10 +5996,10 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); } if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + retVal___ = postHookFunc(retVal___, self, table, out_buf, buf_len, sep); } } return retVal___; @@ -6015,11 +6008,11 @@ int HP_SQL_SetEncoding(struct Sql *self, const char *encoding) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { - int (*preHookFunc) (struct Sql *self, const char *encoding); + int (*preHookFunc) (struct Sql **self, const char **encoding); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; - retVal___ = preHookFunc(self, encoding); + retVal___ = preHookFunc(&self, &encoding); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6042,11 +6035,11 @@ int HP_SQL_Ping(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Ping_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6069,11 +6062,11 @@ size_t HP_SQL_EscapeString(struct Sql *self, char *out_to, const char *from) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeString_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from); + retVal___ = preHookFunc(&self, &out_to, &from); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6096,11 +6089,11 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from, size_t *from_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from, &from_len); + retVal___ = preHookFunc(&self, &out_to, &from, &from_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6111,10 +6104,10 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); } if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { - size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t from_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + retVal___ = postHookFunc(retVal___, self, out_to, from, from_len); } } return retVal___; @@ -6123,12 +6116,12 @@ int HP_SQL_QueryV(struct Sql *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryV_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query, va_list args); + int (*preHookFunc) (struct Sql **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6156,11 +6149,11 @@ int HP_SQL_QueryStr(struct Sql *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryStr_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query); + int (*preHookFunc) (struct Sql **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6183,11 +6176,11 @@ uint64 HP_SQL_LastInsertId(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6210,11 +6203,11 @@ uint32 HP_SQL_NumColumns(struct Sql *self) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumColumns_pre ) { - uint32 (*preHookFunc) (struct Sql *self); + uint32 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6237,11 +6230,11 @@ uint64 HP_SQL_NumRows(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumRows_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6264,11 +6257,11 @@ int HP_SQL_NextRow(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_NextRow_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6291,11 +6284,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetData_pre ) { - int (*preHookFunc) (struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*preHookFunc) (struct Sql **self, size_t *col, char ***out_buf, size_t **out_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; - retVal___ = preHookFunc(self, &col, out_buf, out_len); + retVal___ = preHookFunc(&self, &col, &out_buf, &out_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6306,10 +6299,10 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); } if( HPMHooks.count.HP_SQL_GetData_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*postHookFunc) (int retVal___, struct Sql *self, size_t col, char **out_buf, size_t *out_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + retVal___ = postHookFunc(retVal___, self, col, out_buf, out_len); } } return retVal___; @@ -6317,11 +6310,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len void HP_SQL_FreeResult(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_FreeResult_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6343,11 +6336,11 @@ void HP_SQL_FreeResult(struct Sql *self) { void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { - void (*preHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct Sql **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6358,10 +6351,10 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_ShowDebug__post ) { - void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -6369,11 +6362,11 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned void HP_SQL_Free(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_Free_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6423,11 +6416,11 @@ struct SqlStmt* HP_SQL_StmtMalloc(struct Sql *sql) { int hIndex = 0; struct SqlStmt* retVal___ = NULL; if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { - struct SqlStmt* (*preHookFunc) (struct Sql *sql); + struct SqlStmt* (*preHookFunc) (struct Sql **sql); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; - retVal___ = preHookFunc(sql); + retVal___ = preHookFunc(&sql); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6450,12 +6443,12 @@ int HP_SQL_StmtPrepareV(struct SqlStmt *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query, va_list args); + int (*preHookFunc) (struct SqlStmt **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6483,11 +6476,11 @@ int HP_SQL_StmtPrepareStr(struct SqlStmt *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query); + int (*preHookFunc) (struct SqlStmt **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6510,11 +6503,11 @@ size_t HP_SQL_StmtNumParams(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6537,11 +6530,11 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const void **buffer, size_t *buffer_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6552,10 +6545,10 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); } if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len); } } return retVal___; @@ -6564,11 +6557,11 @@ int HP_SQL_StmtExecute(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6591,11 +6584,11 @@ uint64 HP_SQL_StmtLastInsertId(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6618,11 +6611,11 @@ size_t HP_SQL_StmtNumColumns(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6645,11 +6638,11 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, void **buffer, size_t *buffer_len, uint32 **out_length, int8 **out_is_null); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len, &out_length, &out_is_null); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6660,10 +6653,10 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } } return retVal___; @@ -6672,11 +6665,11 @@ uint64 HP_SQL_StmtNumRows(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6699,11 +6692,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6725,11 +6718,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { void HP_SQL_StmtFreeResult(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6751,11 +6744,11 @@ void HP_SQL_StmtFreeResult(struct SqlStmt *self) { void HP_SQL_StmtFree(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFree_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6777,11 +6770,11 @@ void HP_SQL_StmtFree(struct SqlStmt *self) { void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { - void (*preHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct SqlStmt **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6792,10 +6785,10 @@ void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const u HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { - void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -6831,11 +6824,11 @@ StringBuf* HP_StrBuf_Malloc(void) { void HP_StrBuf_Init(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Init_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6858,12 +6851,12 @@ int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { - int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + int (*preHookFunc) (StringBuf **self, const char **fmt, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; - retVal___ = preHookFunc(self, fmt, args___copy); + retVal___ = preHookFunc(&self, &fmt, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -6891,11 +6884,11 @@ int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Append_pre ) { - int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + int (*preHookFunc) (StringBuf **self, const StringBuf **sbuf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; - retVal___ = preHookFunc(self, sbuf); + retVal___ = preHookFunc(&self, &sbuf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6918,11 +6911,11 @@ int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { - int (*preHookFunc) (StringBuf *self, const char *str); + int (*preHookFunc) (StringBuf **self, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; - retVal___ = preHookFunc(self, str); + retVal___ = preHookFunc(&self, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6945,11 +6938,11 @@ int HP_StrBuf_Length(StringBuf *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Length_pre ) { - int (*preHookFunc) (StringBuf *self); + int (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6972,11 +6965,11 @@ char* HP_StrBuf_Value(StringBuf *self) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_StrBuf_Value_pre ) { - char* (*preHookFunc) (StringBuf *self); + char* (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6998,11 +6991,11 @@ char* HP_StrBuf_Value(StringBuf *self) { void HP_StrBuf_Clear(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Clear_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7024,11 +7017,11 @@ void HP_StrBuf_Clear(StringBuf *self) { void HP_StrBuf_Destroy(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7050,11 +7043,11 @@ void HP_StrBuf_Destroy(StringBuf *self) { void HP_StrBuf_Free(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Free_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7078,11 +7071,11 @@ char* HP_strlib_jstrescape(char *pt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescape_pre ) { - char* (*preHookFunc) (char *pt); + char* (*preHookFunc) (char **pt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; - retVal___ = preHookFunc(pt); + retVal___ = preHookFunc(&pt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7105,11 +7098,11 @@ char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { - char* (*preHookFunc) (char *pt, const char *spt); + char* (*preHookFunc) (char **pt, const char **spt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt); + retVal___ = preHookFunc(&pt, &spt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7132,11 +7125,11 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { - int (*preHookFunc) (char *pt, const char *spt, int *size); + int (*preHookFunc) (char **pt, const char **spt, int *size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt, &size); + retVal___ = preHookFunc(&pt, &spt, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7147,10 +7140,10 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); } if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { - int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int size); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pt, spt, &size); + retVal___ = postHookFunc(retVal___, pt, spt, size); } } return retVal___; @@ -7159,11 +7152,11 @@ int HP_strlib_remove_control_chars_(char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { - int (*preHookFunc) (char *str); + int (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7186,11 +7179,11 @@ char* HP_strlib_trim_(char *str) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_trim__pre ) { - char* (*preHookFunc) (char *str); + char* (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7213,11 +7206,11 @@ char* HP_strlib_normalize_name_(char *str, const char *delims) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_normalize_name__pre ) { - char* (*preHookFunc) (char *str, const char *delims); + char* (*preHookFunc) (char **str, const char **delims); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; - retVal___ = preHookFunc(str, delims); + retVal___ = preHookFunc(&str, &delims); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7240,11 +7233,11 @@ const char* HP_strlib_stristr_(const char *haystack, const char *needle) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_stristr__pre ) { - const char* (*preHookFunc) (const char *haystack, const char *needle); + const char* (*preHookFunc) (const char **haystack, const char **needle); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; - retVal___ = preHookFunc(haystack, needle); + retVal___ = preHookFunc(&haystack, &needle); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7267,11 +7260,11 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_strnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7282,10 +7275,10 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_strnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -7294,11 +7287,11 @@ char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_strtok_r__pre ) { - char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + char* (*preHookFunc) (char **s1, const char **s2, char ***lasts); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; - retVal___ = preHookFunc(s1, s2, lasts); + retVal___ = preHookFunc(&s1, &s2, &lasts); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7321,11 +7314,11 @@ int HP_strlib_e_mail_check_(char *email) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { - int (*preHookFunc) (char *email); + int (*preHookFunc) (char **email); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; - retVal___ = preHookFunc(email); + retVal___ = preHookFunc(&email); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7348,11 +7341,11 @@ int HP_strlib_config_switch_(const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_config_switch__pre ) { - int (*preHookFunc) (const char *str); + int (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7375,11 +7368,11 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { - char* (*preHookFunc) (char *dst, const char *src, size_t *n); + char* (*preHookFunc) (char **dst, const char **src, size_t *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; - retVal___ = preHookFunc(dst, src, &n); + retVal___ = preHookFunc(&dst, &src, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7390,10 +7383,10 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); } if( HPMHooks.count.HP_strlib_safestrncpy__post ) { - char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t n); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; - retVal___ = postHookFunc(retVal___, dst, src, &n); + retVal___ = postHookFunc(retVal___, dst, src, n); } } return retVal___; @@ -7402,11 +7395,11 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7417,10 +7410,10 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_safestrnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -7429,11 +7422,11 @@ int HP_strlib_strline_(const char *str, size_t pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_strline__pre ) { - int (*preHookFunc) (const char *str, size_t *pos); + int (*preHookFunc) (const char **str, size_t *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; - retVal___ = preHookFunc(str, &pos); + retVal___ = preHookFunc(&str, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7444,10 +7437,10 @@ int HP_strlib_strline_(const char *str, size_t pos) { retVal___ = HPMHooks.source.strlib.strline_(str, pos); } if( HPMHooks.count.HP_strlib_strline__post ) { - int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + int (*postHookFunc) (int retVal___, const char *str, size_t pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &pos); + retVal___ = postHookFunc(retVal___, str, pos); } } return retVal___; @@ -7456,11 +7449,11 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_strlib_bin2hex__pre ) { - bool (*preHookFunc) (char *output, const unsigned char *input, size_t *count); + bool (*preHookFunc) (char **output, const unsigned char **input, size_t *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; - retVal___ = preHookFunc(output, input, &count); + retVal___ = preHookFunc(&output, &input, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7471,10 +7464,10 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); } if( HPMHooks.count.HP_strlib_bin2hex__post ) { - bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t *count); + bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t count); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; - retVal___ = postHookFunc(retVal___, output, input, &count); + retVal___ = postHookFunc(retVal___, output, input, count); } } return retVal___; @@ -7484,11 +7477,11 @@ int HP_sv_parse_next(struct s_svstate *svstate) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_next_pre ) { - int (*preHookFunc) (struct s_svstate *svstate); + int (*preHookFunc) (struct s_svstate **svstate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; - retVal___ = preHookFunc(svstate); + retVal___ = preHookFunc(&svstate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7511,11 +7504,11 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_pre ) { - int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*preHookFunc) (const char **str, int *len, int *startoff, char *delim, int **out_pos, int *npos, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_pos, &npos, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7526,10 +7519,10 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); } if( HPMHooks.count.HP_sv_parse_post ) { - int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_pos, npos, opt); } } return retVal___; @@ -7538,11 +7531,11 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_split_pre ) { - int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*preHookFunc) (char **str, int *len, int *startoff, char *delim, char ***out_fields, int *nfields, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_fields, &nfields, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7553,10 +7546,10 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); } if( HPMHooks.count.HP_sv_split_post ) { - int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_fields, nfields, opt); } } return retVal___; @@ -7565,11 +7558,11 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_escape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len, const char **escapes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len, escapes); + retVal___ = preHookFunc(&out_dest, &src, &len, &escapes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7580,10 +7573,10 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); } if( HPMHooks.count.HP_sv_escape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len, const char *escapes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + retVal___ = postHookFunc(retVal___, out_dest, src, len, escapes); } } return retVal___; @@ -7592,11 +7585,11 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_unescape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len); + retVal___ = preHookFunc(&out_dest, &src, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7607,10 +7600,10 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); } if( HPMHooks.count.HP_sv_unescape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len); + retVal___ = postHookFunc(retVal___, out_dest, src, len); } } return retVal___; @@ -7619,11 +7612,11 @@ const char* HP_sv_skip_escaped_c(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7646,11 +7639,11 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_sv_readdb_pre ) { - bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*preHookFunc) (const char **directory, const char **filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( **parseproc ) (char *fields[], int columns, int current)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; - retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = preHookFunc(&directory, &filename, &delim, &mincols, &maxcols, &maxrows, &parseproc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7661,10 +7654,10 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); } if( HPMHooks.count.HP_sv_readdb_post ) { - bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = postHookFunc(retVal___, directory, filename, delim, mincols, maxcols, maxrows, parseproc); } } return retVal___; @@ -8227,10 +8220,10 @@ int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { retVal___ = HPMHooks.source.timer.add(tick, func, id, data); } if( HPMHooks.count.HP_timer_add_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + retVal___ = postHookFunc(retVal___, tick, func, id, data); } } return retVal___; @@ -8254,10 +8247,10 @@ int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); } if( HPMHooks.count.HP_timer_add_interval_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data, int interval); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + retVal___ = postHookFunc(retVal___, tick, func, id, data, interval); } } return retVal___; @@ -8281,10 +8274,10 @@ const struct TimerData* HP_timer_get(int tid) { retVal___ = HPMHooks.source.timer.get(tid); } if( HPMHooks.count.HP_timer_get_post ) { - const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int tid); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid); + retVal___ = postHookFunc(retVal___, tid); } } return retVal___; @@ -8308,10 +8301,10 @@ int HP_timer_delete(int tid, TimerFunc func) { retVal___ = HPMHooks.source.timer.delete(tid, func); } if( HPMHooks.count.HP_timer_delete_post ) { - int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + int (*postHookFunc) (int retVal___, int tid, TimerFunc func); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &func); + retVal___ = postHookFunc(retVal___, tid, func); } } return retVal___; @@ -8335,10 +8328,10 @@ int64 HP_timer_addtick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.addtick(tid, tick); } if( HPMHooks.count.HP_timer_addtick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -8362,10 +8355,10 @@ int64 HP_timer_settick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.settick(tid, tick); } if( HPMHooks.count.HP_timer_settick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -8374,11 +8367,11 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_timer_add_func_list_pre ) { - int (*preHookFunc) (TimerFunc *func, char *name); + int (*preHookFunc) (TimerFunc *func, char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; - retVal___ = preHookFunc(&func, name); + retVal___ = preHookFunc(&func, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8389,10 +8382,10 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { retVal___ = HPMHooks.source.timer.add_func_list(func, name); } if( HPMHooks.count.HP_timer_add_func_list_post ) { - int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + int (*postHookFunc) (int retVal___, TimerFunc func, char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &func, name); + retVal___ = postHookFunc(retVal___, func, name); } } return retVal___; @@ -8443,10 +8436,10 @@ int HP_timer_perform(int64 tick) { retVal___ = HPMHooks.source.timer.perform(tick); } if( HPMHooks.count.HP_timer_perform_post ) { - int (*postHookFunc) (int retVal___, int64 *tick); + int (*postHookFunc) (int retVal___, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick); + retVal___ = postHookFunc(retVal___, tick); } } return retVal___; diff --git a/src/plugins/HPMHooking/HPMHooking_login.sources.inc b/src/plugins/HPMHooking/HPMHooking_login.sources.inc index 1c1927619..10558043c 100644 --- a/src/plugins/HPMHooking/HPMHooking_login.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_login.sources.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); memcpy(&HPMHooks.source.cmdline, cmdline, sizeof(struct cmdline_interface)); memcpy(&HPMHooks.source.console, console, sizeof(struct console_interface)); diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc index a11e964c2..0b224127e 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct { struct HPMHookPoint *HP_HCache_init_pre; struct HPMHookPoint *HP_HCache_init_post; @@ -114,6 +116,8 @@ struct { struct HPMHookPoint *HP_battle_calc_bg_damage_post; struct HPMHookPoint *HP_battle_weapon_attack_pre; struct HPMHookPoint *HP_battle_weapon_attack_post; + struct HPMHookPoint *HP_battle_check_arrows_pre; + struct HPMHookPoint *HP_battle_check_arrows_post; struct HPMHookPoint *HP_battle_calc_weapon_attack_pre; struct HPMHookPoint *HP_battle_calc_weapon_attack_post; struct HPMHookPoint *HP_battle_delay_damage_pre; @@ -984,8 +988,10 @@ struct { struct HPMHookPoint *HP_clif_message_post; struct HPMHookPoint *HP_clif_messageln_pre; struct HPMHookPoint *HP_clif_messageln_post; - struct HPMHookPoint *HP_clif_process_message_pre; - struct HPMHookPoint *HP_clif_process_message_post; + struct HPMHookPoint *HP_clif_process_chat_message_pre; + struct HPMHookPoint *HP_clif_process_chat_message_post; + struct HPMHookPoint *HP_clif_process_whisper_message_pre; + struct HPMHookPoint *HP_clif_process_whisper_message_post; struct HPMHookPoint *HP_clif_wisexin_pre; struct HPMHookPoint *HP_clif_wisexin_post; struct HPMHookPoint *HP_clif_wisall_pre; @@ -1388,6 +1394,10 @@ struct { struct HPMHookPoint *HP_clif_comparemergeitem_post; struct HPMHookPoint *HP_clif_ackmergeitems_pre; struct HPMHookPoint *HP_clif_ackmergeitems_post; + struct HPMHookPoint *HP_clif_isdisguised_pre; + struct HPMHookPoint *HP_clif_isdisguised_post; + struct HPMHookPoint *HP_clif_bl_type_pre; + struct HPMHookPoint *HP_clif_bl_type_post; struct HPMHookPoint *HP_clif_pWantToConnection_pre; struct HPMHookPoint *HP_clif_pWantToConnection_post; struct HPMHookPoint *HP_clif_pLoadEndAck_pre; @@ -2612,6 +2622,10 @@ struct { struct HPMHookPoint *HP_ircbot_identify_timer_post; struct HPMHookPoint *HP_ircbot_join_timer_pre; struct HPMHookPoint *HP_ircbot_join_timer_post; + struct HPMHookPoint *HP_ircbot_queue_timer_pre; + struct HPMHookPoint *HP_ircbot_queue_timer_post; + struct HPMHookPoint *HP_ircbot_queue_pre; + struct HPMHookPoint *HP_ircbot_queue_post; struct HPMHookPoint *HP_ircbot_send_pre; struct HPMHookPoint *HP_ircbot_send_post; struct HPMHookPoint *HP_ircbot_relay_pre; @@ -2620,6 +2634,8 @@ struct { struct HPMHookPoint *HP_ircbot_pong_post; struct HPMHookPoint *HP_ircbot_privmsg_pre; struct HPMHookPoint *HP_ircbot_privmsg_post; + struct HPMHookPoint *HP_ircbot_privmsg_ctcp_pre; + struct HPMHookPoint *HP_ircbot_privmsg_ctcp_post; struct HPMHookPoint *HP_ircbot_userjoin_pre; struct HPMHookPoint *HP_ircbot_userjoin_post; struct HPMHookPoint *HP_ircbot_userleave_pre; @@ -4356,6 +4372,10 @@ struct { struct HPMHookPoint *HP_pc_update_idle_time_post; struct HPMHookPoint *HP_pc_have_magnifier_pre; struct HPMHookPoint *HP_pc_have_magnifier_post; + struct HPMHookPoint *HP_pc_process_chat_message_pre; + struct HPMHookPoint *HP_pc_process_chat_message_post; + struct HPMHookPoint *HP_pc_check_supernovice_call_pre; + struct HPMHookPoint *HP_pc_check_supernovice_call_post; struct HPMHookPoint *HP_libpcre_compile_pre; struct HPMHookPoint *HP_libpcre_compile_post; struct HPMHookPoint *HP_libpcre_study_pre; @@ -4654,6 +4674,16 @@ struct { struct HPMHookPoint *HP_script_parse_variable_post; struct HPMHookPoint *HP_script_parse_simpleexpr_pre; struct HPMHookPoint *HP_script_parse_simpleexpr_post; + struct HPMHookPoint *HP_script_parse_simpleexpr_paren_pre; + struct HPMHookPoint *HP_script_parse_simpleexpr_paren_post; + struct HPMHookPoint *HP_script_parse_simpleexpr_number_pre; + struct HPMHookPoint *HP_script_parse_simpleexpr_number_post; + struct HPMHookPoint *HP_script_parse_simpleexpr_string_pre; + struct HPMHookPoint *HP_script_parse_simpleexpr_string_post; + struct HPMHookPoint *HP_script_parse_simpleexpr_name_pre; + struct HPMHookPoint *HP_script_parse_simpleexpr_name_post; + struct HPMHookPoint *HP_script_add_translatable_string_pre; + struct HPMHookPoint *HP_script_add_translatable_string_post; struct HPMHookPoint *HP_script_parse_expr_pre; struct HPMHookPoint *HP_script_parse_expr_post; struct HPMHookPoint *HP_script_parse_line_pre; @@ -5278,6 +5308,12 @@ struct { struct HPMHookPoint *HP_skill_get_requirement_item_unknown_post; struct HPMHookPoint *HP_skill_get_requirement_unknown_pre; struct HPMHookPoint *HP_skill_get_requirement_unknown_post; + struct HPMHookPoint *HP_skill_splash_target_pre; + struct HPMHookPoint *HP_skill_splash_target_post; + struct HPMHookPoint *HP_skill_check_npc_chaospanic_pre; + struct HPMHookPoint *HP_skill_check_npc_chaospanic_post; + struct HPMHookPoint *HP_skill_count_wos_pre; + struct HPMHookPoint *HP_skill_count_wos_post; struct HPMHookPoint *HP_sockt_init_pre; struct HPMHookPoint *HP_sockt_init_post; struct HPMHookPoint *HP_sockt_final_pre; @@ -5622,6 +5658,14 @@ struct { struct HPMHookPoint *HP_status_read_job_db_post; struct HPMHookPoint *HP_status_read_job_db_sub_pre; struct HPMHookPoint *HP_status_read_job_db_sub_post; + struct HPMHookPoint *HP_status_set_sc_pre; + struct HPMHookPoint *HP_status_set_sc_post; + struct HPMHookPoint *HP_status_copy_pre; + struct HPMHookPoint *HP_status_copy_post; + struct HPMHookPoint *HP_status_base_matk_min_pre; + struct HPMHookPoint *HP_status_base_matk_min_post; + struct HPMHookPoint *HP_status_base_matk_max_pre; + struct HPMHookPoint *HP_status_base_matk_max_post; struct HPMHookPoint *HP_storage_reconnect_pre; struct HPMHookPoint *HP_storage_reconnect_post; struct HPMHookPoint *HP_storage_delitem_pre; @@ -5800,6 +5844,8 @@ struct { struct HPMHookPoint *HP_unit_bl2ud_post; struct HPMHookPoint *HP_unit_bl2ud2_pre; struct HPMHookPoint *HP_unit_bl2ud2_post; + struct HPMHookPoint *HP_unit_init_ud_pre; + struct HPMHookPoint *HP_unit_init_ud_post; struct HPMHookPoint *HP_unit_attack_timer_pre; struct HPMHookPoint *HP_unit_attack_timer_post; struct HPMHookPoint *HP_unit_walktoxy_timer_pre; @@ -5997,6 +6043,8 @@ struct { int HP_battle_calc_bg_damage_post; int HP_battle_weapon_attack_pre; int HP_battle_weapon_attack_post; + int HP_battle_check_arrows_pre; + int HP_battle_check_arrows_post; int HP_battle_calc_weapon_attack_pre; int HP_battle_calc_weapon_attack_post; int HP_battle_delay_damage_pre; @@ -6867,8 +6915,10 @@ struct { int HP_clif_message_post; int HP_clif_messageln_pre; int HP_clif_messageln_post; - int HP_clif_process_message_pre; - int HP_clif_process_message_post; + int HP_clif_process_chat_message_pre; + int HP_clif_process_chat_message_post; + int HP_clif_process_whisper_message_pre; + int HP_clif_process_whisper_message_post; int HP_clif_wisexin_pre; int HP_clif_wisexin_post; int HP_clif_wisall_pre; @@ -7271,6 +7321,10 @@ struct { int HP_clif_comparemergeitem_post; int HP_clif_ackmergeitems_pre; int HP_clif_ackmergeitems_post; + int HP_clif_isdisguised_pre; + int HP_clif_isdisguised_post; + int HP_clif_bl_type_pre; + int HP_clif_bl_type_post; int HP_clif_pWantToConnection_pre; int HP_clif_pWantToConnection_post; int HP_clif_pLoadEndAck_pre; @@ -8495,6 +8549,10 @@ struct { int HP_ircbot_identify_timer_post; int HP_ircbot_join_timer_pre; int HP_ircbot_join_timer_post; + int HP_ircbot_queue_timer_pre; + int HP_ircbot_queue_timer_post; + int HP_ircbot_queue_pre; + int HP_ircbot_queue_post; int HP_ircbot_send_pre; int HP_ircbot_send_post; int HP_ircbot_relay_pre; @@ -8503,6 +8561,8 @@ struct { int HP_ircbot_pong_post; int HP_ircbot_privmsg_pre; int HP_ircbot_privmsg_post; + int HP_ircbot_privmsg_ctcp_pre; + int HP_ircbot_privmsg_ctcp_post; int HP_ircbot_userjoin_pre; int HP_ircbot_userjoin_post; int HP_ircbot_userleave_pre; @@ -10239,6 +10299,10 @@ struct { int HP_pc_update_idle_time_post; int HP_pc_have_magnifier_pre; int HP_pc_have_magnifier_post; + int HP_pc_process_chat_message_pre; + int HP_pc_process_chat_message_post; + int HP_pc_check_supernovice_call_pre; + int HP_pc_check_supernovice_call_post; int HP_libpcre_compile_pre; int HP_libpcre_compile_post; int HP_libpcre_study_pre; @@ -10537,6 +10601,16 @@ struct { int HP_script_parse_variable_post; int HP_script_parse_simpleexpr_pre; int HP_script_parse_simpleexpr_post; + int HP_script_parse_simpleexpr_paren_pre; + int HP_script_parse_simpleexpr_paren_post; + int HP_script_parse_simpleexpr_number_pre; + int HP_script_parse_simpleexpr_number_post; + int HP_script_parse_simpleexpr_string_pre; + int HP_script_parse_simpleexpr_string_post; + int HP_script_parse_simpleexpr_name_pre; + int HP_script_parse_simpleexpr_name_post; + int HP_script_add_translatable_string_pre; + int HP_script_add_translatable_string_post; int HP_script_parse_expr_pre; int HP_script_parse_expr_post; int HP_script_parse_line_pre; @@ -11161,6 +11235,12 @@ struct { int HP_skill_get_requirement_item_unknown_post; int HP_skill_get_requirement_unknown_pre; int HP_skill_get_requirement_unknown_post; + int HP_skill_splash_target_pre; + int HP_skill_splash_target_post; + int HP_skill_check_npc_chaospanic_pre; + int HP_skill_check_npc_chaospanic_post; + int HP_skill_count_wos_pre; + int HP_skill_count_wos_post; int HP_sockt_init_pre; int HP_sockt_init_post; int HP_sockt_final_pre; @@ -11505,6 +11585,14 @@ struct { int HP_status_read_job_db_post; int HP_status_read_job_db_sub_pre; int HP_status_read_job_db_sub_post; + int HP_status_set_sc_pre; + int HP_status_set_sc_post; + int HP_status_copy_pre; + int HP_status_copy_post; + int HP_status_base_matk_min_pre; + int HP_status_base_matk_min_post; + int HP_status_base_matk_max_pre; + int HP_status_base_matk_max_post; int HP_storage_reconnect_pre; int HP_storage_reconnect_post; int HP_storage_delitem_pre; @@ -11683,6 +11771,8 @@ struct { int HP_unit_bl2ud_post; int HP_unit_bl2ud2_pre; int HP_unit_bl2ud2_post; + int HP_unit_init_ud_pre; + int HP_unit_init_ud_post; int HP_unit_attack_timer_pre; int HP_unit_attack_timer_post; int HP_unit_walktoxy_timer_pre; diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc index 8d9752849..cc3f9f303 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc @@ -1,5 +1,6 @@ /** * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules * * Copyright (C) 2013-2016 Hercules Dev Team * @@ -22,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + struct HookingPointData HookingPoints[] = { /* HCache_interface */ { HP_POP(HCache->init, HP_HCache_init) }, @@ -71,6 +74,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(battle->calc_gvg_damage, HP_battle_calc_gvg_damage) }, { HP_POP(battle->calc_bg_damage, HP_battle_calc_bg_damage) }, { HP_POP(battle->weapon_attack, HP_battle_weapon_attack) }, + { HP_POP(battle->check_arrows, HP_battle_check_arrows) }, { HP_POP(battle->calc_weapon_attack, HP_battle_calc_weapon_attack) }, { HP_POP(battle->delay_damage, HP_battle_delay_damage) }, { HP_POP(battle->drain, HP_battle_drain) }, @@ -512,7 +516,8 @@ struct HookingPointData HookingPoints[] = { { HP_POP(clif->msgtable_skill, HP_clif_msgtable_skill) }, { HP_POP(clif->message, HP_clif_message) }, { HP_POP(clif->messageln, HP_clif_messageln) }, - { HP_POP(clif->process_message, HP_clif_process_message) }, + { HP_POP(clif->process_chat_message, HP_clif_process_chat_message) }, + { HP_POP(clif->process_whisper_message, HP_clif_process_whisper_message) }, { HP_POP(clif->wisexin, HP_clif_wisexin) }, { HP_POP(clif->wisall, HP_clif_wisall) }, { HP_POP(clif->PMIgnoreList, HP_clif_PMIgnoreList) }, @@ -714,6 +719,8 @@ struct HookingPointData HookingPoints[] = { { HP_POP(clif->cancelmergeitem, HP_clif_cancelmergeitem) }, { HP_POP(clif->comparemergeitem, HP_clif_comparemergeitem) }, { HP_POP(clif->ackmergeitems, HP_clif_ackmergeitems) }, + { HP_POP(clif->isdisguised, HP_clif_isdisguised) }, + { HP_POP(clif->bl_type, HP_clif_bl_type) }, { HP_POP(clif->pWantToConnection, HP_clif_pWantToConnection) }, { HP_POP(clif->pLoadEndAck, HP_clif_pLoadEndAck) }, { HP_POP(clif->pTickSend, HP_clif_pTickSend) }, @@ -1338,10 +1345,13 @@ struct HookingPointData HookingPoints[] = { { HP_POP(ircbot->connect_timer, HP_ircbot_connect_timer) }, { HP_POP(ircbot->identify_timer, HP_ircbot_identify_timer) }, { HP_POP(ircbot->join_timer, HP_ircbot_join_timer) }, + { HP_POP(ircbot->queue_timer, HP_ircbot_queue_timer) }, + { HP_POP(ircbot->queue, HP_ircbot_queue) }, { HP_POP(ircbot->send, HP_ircbot_send) }, { HP_POP(ircbot->relay, HP_ircbot_relay) }, { HP_POP(ircbot->pong, HP_ircbot_pong) }, { HP_POP(ircbot->privmsg, HP_ircbot_privmsg) }, + { HP_POP(ircbot->privmsg_ctcp, HP_ircbot_privmsg_ctcp) }, { HP_POP(ircbot->userjoin, HP_ircbot_userjoin) }, { HP_POP(ircbot->userleave, HP_ircbot_userleave) }, { HP_POP(ircbot->usernick, HP_ircbot_usernick) }, @@ -2228,6 +2238,8 @@ struct HookingPointData HookingPoints[] = { { HP_POP(pc->check_job_name, HP_pc_check_job_name) }, { HP_POP(pc->update_idle_time, HP_pc_update_idle_time) }, { HP_POP(pc->have_magnifier, HP_pc_have_magnifier) }, + { HP_POP(pc->process_chat_message, HP_pc_process_chat_message) }, + { HP_POP(pc->check_supernovice_call, HP_pc_check_supernovice_call) }, /* pcre_interface */ { HP_POP(libpcre->compile, HP_libpcre_compile) }, { HP_POP(libpcre->study, HP_libpcre_study) }, @@ -2381,6 +2393,11 @@ struct HookingPointData HookingPoints[] = { { HP_POP(script->parse_nextline, HP_script_parse_nextline) }, { HP_POP(script->parse_variable, HP_script_parse_variable) }, { HP_POP(script->parse_simpleexpr, HP_script_parse_simpleexpr) }, + { HP_POP(script->parse_simpleexpr_paren, HP_script_parse_simpleexpr_paren) }, + { HP_POP(script->parse_simpleexpr_number, HP_script_parse_simpleexpr_number) }, + { HP_POP(script->parse_simpleexpr_string, HP_script_parse_simpleexpr_string) }, + { HP_POP(script->parse_simpleexpr_name, HP_script_parse_simpleexpr_name) }, + { HP_POP(script->add_translatable_string, HP_script_add_translatable_string) }, { HP_POP(script->parse_expr, HP_script_parse_expr) }, { HP_POP(script->parse_line, HP_script_parse_line) }, { HP_POP(script->read_constdb, HP_script_read_constdb) }, @@ -2696,6 +2713,9 @@ struct HookingPointData HookingPoints[] = { { HP_POP(skill->get_requirement_off_unknown, HP_skill_get_requirement_off_unknown) }, { HP_POP(skill->get_requirement_item_unknown, HP_skill_get_requirement_item_unknown) }, { HP_POP(skill->get_requirement_unknown, HP_skill_get_requirement_unknown) }, + { HP_POP(skill->splash_target, HP_skill_splash_target) }, + { HP_POP(skill->check_npc_chaospanic, HP_skill_check_npc_chaospanic) }, + { HP_POP(skill->count_wos, HP_skill_count_wos) }, /* socket_interface */ { HP_POP(sockt->init, HP_sockt_init) }, { HP_POP(sockt->final, HP_sockt_final) }, @@ -2871,6 +2891,10 @@ struct HookingPointData HookingPoints[] = { { HP_POP(status->readdb_scconfig, HP_status_readdb_scconfig) }, { HP_POP(status->read_job_db, HP_status_read_job_db) }, { HP_POP(status->read_job_db_sub, HP_status_read_job_db_sub) }, + { HP_POP(status->set_sc, HP_status_set_sc) }, + { HP_POP(status->copy, HP_status_copy) }, + { HP_POP(status->base_matk_min, HP_status_base_matk_min) }, + { HP_POP(status->base_matk_max, HP_status_base_matk_max) }, /* storage_interface */ { HP_POP(storage->reconnect, HP_storage_reconnect) }, { HP_POP(storage->delitem, HP_storage_delitem) }, @@ -2968,6 +2992,7 @@ struct HookingPointData HookingPoints[] = { { HP_POP(unit->final, HP_unit_final) }, { HP_POP(unit->bl2ud, HP_unit_bl2ud) }, { HP_POP(unit->bl2ud2, HP_unit_bl2ud2) }, + { HP_POP(unit->init_ud, HP_unit_init_ud) }, { HP_POP(unit->attack_timer, HP_unit_attack_timer) }, { HP_POP(unit->walktoxy_timer, HP_unit_walktoxy_timer) }, { HP_POP(unit->walktoxy_sub, HP_unit_walktoxy_sub) }, diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc index fa7b192c6..14b724f63 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + /* HCache_interface */ void HP_HCache_init(void) { int hIndex = 0; @@ -54,11 +56,11 @@ bool HP_HCache_check(const char *file) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_HCache_check_pre ) { - bool (*preHookFunc) (const char *file); + bool (*preHookFunc) (const char **file); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func; - retVal___ = preHookFunc(file); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -81,11 +83,11 @@ FILE* HP_HCache_open(const char *file, const char *opt) { int hIndex = 0; FILE* retVal___ = NULL; if( HPMHooks.count.HP_HCache_open_pre ) { - FILE* (*preHookFunc) (const char *file, const char *opt); + FILE* (*preHookFunc) (const char **file, const char **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func; - retVal___ = preHookFunc(file, opt); + retVal___ = preHookFunc(&file, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -123,10 +125,10 @@ void HP_atcommand_init(bool minimal) { HPMHooks.source.atcommand.init(minimal); } if( HPMHooks.count.HP_atcommand_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -161,11 +163,11 @@ bool HP_atcommand_exec(const int fd, struct map_session_data *sd, const char *me int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_exec_pre ) { - bool (*preHookFunc) (const int *fd, struct map_session_data *sd, const char *message, bool *player_invoked); + bool (*preHookFunc) (const int *fd, struct map_session_data **sd, const char **message, bool *player_invoked); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exec_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_exec_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd, message, &player_invoked); + retVal___ = preHookFunc(&fd, &sd, &message, &player_invoked); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -176,10 +178,10 @@ bool HP_atcommand_exec(const int fd, struct map_session_data *sd, const char *me retVal___ = HPMHooks.source.atcommand.exec(fd, sd, message, player_invoked); } if( HPMHooks.count.HP_atcommand_exec_post ) { - bool (*postHookFunc) (bool retVal___, const int *fd, struct map_session_data *sd, const char *message, bool *player_invoked); + bool (*postHookFunc) (bool retVal___, const int fd, struct map_session_data *sd, const char *message, bool player_invoked); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exec_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_exec_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd, message, &player_invoked); + retVal___ = postHookFunc(retVal___, fd, sd, message, player_invoked); } } return retVal___; @@ -188,11 +190,11 @@ bool HP_atcommand_create(char *name, AtCommandFunc func) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_create_pre ) { - bool (*preHookFunc) (char *name, AtCommandFunc *func); + bool (*preHookFunc) (char **name, AtCommandFunc *func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_create_pre[hIndex].func; - retVal___ = preHookFunc(name, &func); + retVal___ = preHookFunc(&name, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -203,10 +205,10 @@ bool HP_atcommand_create(char *name, AtCommandFunc func) { retVal___ = HPMHooks.source.atcommand.create(name, func); } if( HPMHooks.count.HP_atcommand_create_post ) { - bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc *func); + bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc func); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &func); + retVal___ = postHookFunc(retVal___, name, func); } } return retVal___; @@ -215,11 +217,11 @@ bool HP_atcommand_can_use(struct map_session_data *sd, const char *command) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_can_use_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *command); + bool (*preHookFunc) (struct map_session_data **sd, const char **command); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_can_use_pre[hIndex].func; - retVal___ = preHookFunc(sd, command); + retVal___ = preHookFunc(&sd, &command); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -242,11 +244,11 @@ bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtC int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_can_use2_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *command, AtCommandType *type); + bool (*preHookFunc) (struct map_session_data **sd, const char **command, AtCommandType *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_can_use2_pre[hIndex].func; - retVal___ = preHookFunc(sd, command, &type); + retVal___ = preHookFunc(&sd, &command, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -257,10 +259,10 @@ bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtC retVal___ = HPMHooks.source.atcommand.can_use2(sd, command, type); } if( HPMHooks.count.HP_atcommand_can_use2_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command, AtCommandType *type); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command, AtCommandType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_can_use2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, command, &type); + retVal___ = postHookFunc(retVal___, sd, command, type); } } return retVal___; @@ -268,11 +270,11 @@ bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtC void HP_atcommand_load_groups(GroupSettings **groups, struct config_setting_t **commands_, size_t sz) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_load_groups_pre ) { - void (*preHookFunc) (GroupSettings **groups, struct config_setting_t **commands_, size_t *sz); + void (*preHookFunc) (GroupSettings ***groups, struct config_setting_t ***commands_, size_t *sz); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_load_groups_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_load_groups_pre[hIndex].func; - preHookFunc(groups, commands_, &sz); + preHookFunc(&groups, &commands_, &sz); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -283,10 +285,10 @@ void HP_atcommand_load_groups(GroupSettings **groups, struct config_setting_t ** HPMHooks.source.atcommand.load_groups(groups, commands_, sz); } if( HPMHooks.count.HP_atcommand_load_groups_post ) { - void (*postHookFunc) (GroupSettings **groups, struct config_setting_t **commands_, size_t *sz); + void (*postHookFunc) (GroupSettings **groups, struct config_setting_t **commands_, size_t sz); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_load_groups_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_load_groups_post[hIndex].func; - postHookFunc(groups, commands_, &sz); + postHookFunc(groups, commands_, sz); } } return; @@ -295,11 +297,11 @@ AtCommandInfo* HP_atcommand_exists(const char *name) { int hIndex = 0; AtCommandInfo* retVal___ = NULL; if( HPMHooks.count.HP_atcommand_exists_pre ) { - AtCommandInfo* (*preHookFunc) (const char *name); + AtCommandInfo* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exists_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_exists_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -322,11 +324,11 @@ bool HP_atcommand_msg_read(const char *cfg_name, bool allow_override) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_atcommand_msg_read_pre ) { - bool (*preHookFunc) (const char *cfg_name, bool *allow_override); + bool (*preHookFunc) (const char **cfg_name, bool *allow_override); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_msg_read_pre[hIndex].func; - retVal___ = preHookFunc(cfg_name, &allow_override); + retVal___ = preHookFunc(&cfg_name, &allow_override); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -337,10 +339,10 @@ bool HP_atcommand_msg_read(const char *cfg_name, bool allow_override) { retVal___ = HPMHooks.source.atcommand.msg_read(cfg_name, allow_override); } if( HPMHooks.count.HP_atcommand_msg_read_post ) { - bool (*postHookFunc) (bool retVal___, const char *cfg_name, bool *allow_override); + bool (*postHookFunc) (bool retVal___, const char *cfg_name, bool allow_override); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_msg_read_post[hIndex].func; - retVal___ = postHookFunc(retVal___, cfg_name, &allow_override); + retVal___ = postHookFunc(retVal___, cfg_name, allow_override); } } return retVal___; @@ -375,11 +377,11 @@ struct atcmd_binding_data* HP_atcommand_get_bind_byname(const char *name) { int hIndex = 0; struct atcmd_binding_data* retVal___ = NULL; if( HPMHooks.count.HP_atcommand_get_bind_byname_pre ) { - struct atcmd_binding_data* (*preHookFunc) (const char *name); + struct atcmd_binding_data* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_bind_byname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_get_bind_byname_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -402,11 +404,11 @@ AtCommandInfo* HP_atcommand_get_info_byname(const char *name) { int hIndex = 0; AtCommandInfo* retVal___ = NULL; if( HPMHooks.count.HP_atcommand_get_info_byname_pre ) { - AtCommandInfo* (*preHookFunc) (const char *name); + AtCommandInfo* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_info_byname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_get_info_byname_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -429,11 +431,11 @@ const char* HP_atcommand_check_alias(const char *aliasname) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_atcommand_check_alias_pre ) { - const char* (*preHookFunc) (const char *aliasname); + const char* (*preHookFunc) (const char **aliasname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_check_alias_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_check_alias_pre[hIndex].func; - retVal___ = preHookFunc(aliasname); + retVal___ = preHookFunc(&aliasname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -455,11 +457,11 @@ const char* HP_atcommand_check_alias(const char *aliasname) { void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name, bool is_atcmd_cmd) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_get_suggestions_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name, bool *is_atcmd_cmd); + void (*preHookFunc) (struct map_session_data **sd, const char **name, bool *is_atcmd_cmd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_suggestions_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_get_suggestions_pre[hIndex].func; - preHookFunc(sd, name, &is_atcmd_cmd); + preHookFunc(&sd, &name, &is_atcmd_cmd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -470,10 +472,10 @@ void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name, HPMHooks.source.atcommand.get_suggestions(sd, name, is_atcmd_cmd); } if( HPMHooks.count.HP_atcommand_get_suggestions_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *name, bool *is_atcmd_cmd); + void (*postHookFunc) (struct map_session_data *sd, const char *name, bool is_atcmd_cmd); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_suggestions_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_get_suggestions_post[hIndex].func; - postHookFunc(sd, name, &is_atcmd_cmd); + postHookFunc(sd, name, is_atcmd_cmd); } } return; @@ -481,11 +483,11 @@ void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name, void HP_atcommand_config_read(const char *config_filename) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_config_read_pre ) { - void (*preHookFunc) (const char *config_filename); + void (*preHookFunc) (const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_config_read_pre[hIndex].func; - preHookFunc(config_filename); + preHookFunc(&config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -508,12 +510,12 @@ int HP_atcommand_stopattack(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_stopattack_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_stopattack_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_stopattack_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -541,12 +543,12 @@ int HP_atcommand_pvpoff_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_pvpoff_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpoff_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_pvpoff_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -574,12 +576,12 @@ int HP_atcommand_pvpon_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_pvpon_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpon_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_pvpon_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -607,12 +609,12 @@ int HP_atcommand_atkillmonster_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_atkillmonster_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_atkillmonster_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_atkillmonster_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -639,11 +641,11 @@ int HP_atcommand_atkillmonster_sub(struct block_list *bl, va_list ap) { void HP_atcommand_raise_sub(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_raise_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_raise_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_raise_sub_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -665,11 +667,11 @@ void HP_atcommand_raise_sub(struct map_session_data *sd) { void HP_atcommand_get_jail_time(int jailtime, int *year, int *month, int *day, int *hour, int *minute) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_get_jail_time_pre ) { - void (*preHookFunc) (int *jailtime, int *year, int *month, int *day, int *hour, int *minute); + void (*preHookFunc) (int *jailtime, int **year, int **month, int **day, int **hour, int **minute); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_jail_time_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_get_jail_time_pre[hIndex].func; - preHookFunc(&jailtime, year, month, day, hour, minute); + preHookFunc(&jailtime, &year, &month, &day, &hour, &minute); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -680,10 +682,10 @@ void HP_atcommand_get_jail_time(int jailtime, int *year, int *month, int *day, i HPMHooks.source.atcommand.get_jail_time(jailtime, year, month, day, hour, minute); } if( HPMHooks.count.HP_atcommand_get_jail_time_post ) { - void (*postHookFunc) (int *jailtime, int *year, int *month, int *day, int *hour, int *minute); + void (*postHookFunc) (int jailtime, int *year, int *month, int *day, int *hour, int *minute); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_jail_time_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_get_jail_time_post[hIndex].func; - postHookFunc(&jailtime, year, month, day, hour, minute); + postHookFunc(jailtime, year, month, day, hour, minute); } } return; @@ -692,12 +694,12 @@ int HP_atcommand_cleanfloor_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_cleanfloor_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cleanfloor_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_cleanfloor_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -725,12 +727,12 @@ int HP_atcommand_mutearea_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_mutearea_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_mutearea_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_atcommand_mutearea_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -757,11 +759,11 @@ int HP_atcommand_mutearea_sub(struct block_list *bl, va_list ap) { void HP_atcommand_getring(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_getring_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_getring_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_getring_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -783,11 +785,11 @@ void HP_atcommand_getring(struct map_session_data *sd) { void HP_atcommand_channel_help(int fd, const char *command, bool can_create) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_channel_help_pre ) { - void (*preHookFunc) (int *fd, const char *command, bool *can_create); + void (*preHookFunc) (int *fd, const char **command, bool *can_create); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_channel_help_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_channel_help_pre[hIndex].func; - preHookFunc(&fd, command, &can_create); + preHookFunc(&fd, &command, &can_create); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -798,10 +800,10 @@ void HP_atcommand_channel_help(int fd, const char *command, bool can_create) { HPMHooks.source.atcommand.channel_help(fd, command, can_create); } if( HPMHooks.count.HP_atcommand_channel_help_post ) { - void (*postHookFunc) (int *fd, const char *command, bool *can_create); + void (*postHookFunc) (int fd, const char *command, bool can_create); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_channel_help_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_channel_help_post[hIndex].func; - postHookFunc(&fd, command, &can_create); + postHookFunc(fd, command, can_create); } } return; @@ -809,11 +811,11 @@ void HP_atcommand_channel_help(int fd, const char *command, bool can_create) { void HP_atcommand_commands_sub(struct map_session_data *sd, const int fd, AtCommandType type) { int hIndex = 0; if( HPMHooks.count.HP_atcommand_commands_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const int *fd, AtCommandType *type); + void (*preHookFunc) (struct map_session_data **sd, const int *fd, AtCommandType *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_commands_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_commands_sub_pre[hIndex].func; - preHookFunc(sd, &fd, &type); + preHookFunc(&sd, &fd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -824,10 +826,10 @@ void HP_atcommand_commands_sub(struct map_session_data *sd, const int fd, AtComm HPMHooks.source.atcommand.commands_sub(sd, fd, type); } if( HPMHooks.count.HP_atcommand_commands_sub_post ) { - void (*postHookFunc) (struct map_session_data *sd, const int *fd, AtCommandType *type); + void (*postHookFunc) (struct map_session_data *sd, const int fd, AtCommandType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_commands_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_commands_sub_post[hIndex].func; - postHookFunc(sd, &fd, &type); + postHookFunc(sd, fd, type); } } return; @@ -862,12 +864,12 @@ int HP_atcommand_cmd_db_clear_sub(union DBKey key, struct DBData *data, va_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list args); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, args___copy); + retVal___ = preHookFunc(&key, &data, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -881,11 +883,11 @@ int HP_atcommand_cmd_db_clear_sub(union DBKey key, struct DBData *data, va_list va_end(args___copy); } if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list args); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, args___copy); + retVal___ = postHookFunc(retVal___, key, data, args___copy); va_end(args___copy); } } @@ -947,11 +949,11 @@ 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 *replace); + bool (*preHookFunc) (char **name, AtCommandFunc *func, bool *replace); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_add_pre[hIndex].func; - retVal___ = preHookFunc(name, &func, &replace); + retVal___ = preHookFunc(&name, &func, &replace); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -962,10 +964,10 @@ bool HP_atcommand_add(char *name, AtCommandFunc func, bool replace) { retVal___ = HPMHooks.source.atcommand.add(name, func, replace); } if( HPMHooks.count.HP_atcommand_add_post ) { - bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc *func, bool *replace); + 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, &replace); + retVal___ = postHookFunc(retVal___, name, func, replace); } } return retVal___; @@ -989,10 +991,10 @@ const char* HP_atcommand_msg(int msg_number) { retVal___ = HPMHooks.source.atcommand.msg(msg_number); } if( HPMHooks.count.HP_atcommand_msg_post ) { - const char* (*postHookFunc) (const char* retVal___, int *msg_number); + const char* (*postHookFunc) (const char* retVal___, int msg_number); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_msg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &msg_number); + retVal___ = postHookFunc(retVal___, msg_number); } } return retVal___; @@ -1042,10 +1044,10 @@ const char* HP_atcommand_msgfd(int fd, int msg_number) { retVal___ = HPMHooks.source.atcommand.msgfd(fd, msg_number); } if( HPMHooks.count.HP_atcommand_msgfd_post ) { - const char* (*postHookFunc) (const char* retVal___, int *fd, int *msg_number); + const char* (*postHookFunc) (const char* retVal___, int fd, int msg_number); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgfd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_msgfd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &msg_number); + retVal___ = postHookFunc(retVal___, fd, msg_number); } } return retVal___; @@ -1054,11 +1056,11 @@ const char* HP_atcommand_msgsd(struct map_session_data *sd, int msg_number) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_atcommand_msgsd_pre ) { - const char* (*preHookFunc) (struct map_session_data *sd, int *msg_number); + const char* (*preHookFunc) (struct map_session_data **sd, int *msg_number); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgsd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_atcommand_msgsd_pre[hIndex].func; - retVal___ = preHookFunc(sd, &msg_number); + retVal___ = preHookFunc(&sd, &msg_number); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1069,10 +1071,10 @@ const char* HP_atcommand_msgsd(struct map_session_data *sd, int msg_number) { retVal___ = HPMHooks.source.atcommand.msgsd(sd, msg_number); } if( HPMHooks.count.HP_atcommand_msgsd_post ) { - const char* (*postHookFunc) (const char* retVal___, struct map_session_data *sd, int *msg_number); + const char* (*postHookFunc) (const char* retVal___, struct map_session_data *sd, int msg_number); for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgsd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_atcommand_msgsd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &msg_number); + retVal___ = postHookFunc(retVal___, sd, msg_number); } } return retVal___; @@ -1096,10 +1098,10 @@ void HP_battle_init(bool minimal) { HPMHooks.source.battle.init(minimal); } if( HPMHooks.count.HP_battle_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -1132,14 +1134,13 @@ void HP_battle_final(void) { } struct Damage HP_battle_calc_attack(int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count) { int hIndex = 0; - struct Damage retVal___; - memset(&retVal___, '\0', sizeof(struct Damage)); + struct Damage retVal___ = { 0 }; if( HPMHooks.count.HP_battle_calc_attack_pre ) { - struct Damage (*preHookFunc) (int *attack_type, struct block_list *bl, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *count); + struct Damage (*preHookFunc) (int *attack_type, struct block_list **bl, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_attack_pre[hIndex].func; - retVal___ = preHookFunc(&attack_type, bl, target, &skill_id, &skill_lv, &count); + retVal___ = preHookFunc(&attack_type, &bl, &target, &skill_id, &skill_lv, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1150,10 +1151,10 @@ struct Damage HP_battle_calc_attack(int attack_type, struct block_list *bl, stru retVal___ = HPMHooks.source.battle.calc_attack(attack_type, bl, target, skill_id, skill_lv, count); } if( HPMHooks.count.HP_battle_calc_attack_post ) { - struct Damage (*postHookFunc) (struct Damage retVal___, int *attack_type, struct block_list *bl, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *count); + struct Damage (*postHookFunc) (struct Damage retVal___, int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &attack_type, bl, target, &skill_id, &skill_lv, &count); + retVal___ = postHookFunc(retVal___, attack_type, bl, target, skill_id, skill_lv, count); } } return retVal___; @@ -1162,11 +1163,11 @@ int64 HP_battle_calc_damage(struct block_list *src, struct block_list *bl, struc int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_damage_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, struct Damage *d, int64 *damage, uint16 *skill_id, uint16 *skill_lv); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, struct Damage **d, int64 *damage, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, d, &damage, &skill_id, &skill_lv); + retVal___ = preHookFunc(&src, &bl, &d, &damage, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1177,10 +1178,10 @@ int64 HP_battle_calc_damage(struct block_list *src, struct block_list *bl, struc retVal___ = HPMHooks.source.battle.calc_damage(src, bl, d, damage, skill_id, skill_lv); } if( HPMHooks.count.HP_battle_calc_damage_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 *damage, uint16 *skill_id, uint16 *skill_lv); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, d, &damage, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, src, bl, d, damage, skill_id, skill_lv); } } return retVal___; @@ -1189,11 +1190,11 @@ int64 HP_battle_calc_gvg_damage(struct block_list *src, struct block_list *bl, i int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_gvg_damage_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_gvg_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_gvg_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &damage, &div_, &skill_id, &skill_lv, &flag); + retVal___ = preHookFunc(&src, &bl, &damage, &div_, &skill_id, &skill_lv, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1204,10 +1205,10 @@ int64 HP_battle_calc_gvg_damage(struct block_list *src, struct block_list *bl, i retVal___ = HPMHooks.source.battle.calc_gvg_damage(src, bl, damage, div_, skill_id, skill_lv, flag); } if( HPMHooks.count.HP_battle_calc_gvg_damage_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_gvg_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_gvg_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &damage, &div_, &skill_id, &skill_lv, &flag); + retVal___ = postHookFunc(retVal___, src, bl, damage, div_, skill_id, skill_lv, flag); } } return retVal___; @@ -1216,11 +1217,11 @@ int64 HP_battle_calc_bg_damage(struct block_list *src, struct block_list *bl, in int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_bg_damage_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_bg_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_bg_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &damage, &div_, &skill_id, &skill_lv, &flag); + retVal___ = preHookFunc(&src, &bl, &damage, &div_, &skill_id, &skill_lv, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1231,10 +1232,10 @@ int64 HP_battle_calc_bg_damage(struct block_list *src, struct block_list *bl, in retVal___ = HPMHooks.source.battle.calc_bg_damage(src, bl, damage, div_, skill_id, skill_lv, flag); } if( HPMHooks.count.HP_battle_calc_bg_damage_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_bg_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_bg_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &damage, &div_, &skill_id, &skill_lv, &flag); + retVal___ = postHookFunc(retVal___, src, bl, damage, div_, skill_id, skill_lv, flag); } } return retVal___; @@ -1243,11 +1244,11 @@ enum damage_lv HP_battle_weapon_attack(struct block_list *bl, struct block_list int hIndex = 0; enum damage_lv retVal___ = ATK_NONE; if( HPMHooks.count.HP_battle_weapon_attack_pre ) { - enum damage_lv (*preHookFunc) (struct block_list *bl, struct block_list *target, int64 *tick, int *flag); + enum damage_lv (*preHookFunc) (struct block_list **bl, struct block_list **target, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_weapon_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_weapon_attack_pre[hIndex].func; - retVal___ = preHookFunc(bl, target, &tick, &flag); + retVal___ = preHookFunc(&bl, &target, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1258,24 +1259,50 @@ enum damage_lv HP_battle_weapon_attack(struct block_list *bl, struct block_list retVal___ = HPMHooks.source.battle.weapon_attack(bl, target, tick, flag); } if( HPMHooks.count.HP_battle_weapon_attack_post ) { - enum damage_lv (*postHookFunc) (enum damage_lv retVal___, struct block_list *bl, struct block_list *target, int64 *tick, int *flag); + enum damage_lv (*postHookFunc) (enum damage_lv retVal___, struct block_list *bl, struct block_list *target, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_weapon_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_weapon_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, target, &tick, &flag); + retVal___ = postHookFunc(retVal___, bl, target, tick, flag); + } + } + return retVal___; +} +bool HP_battle_check_arrows(struct map_session_data *sd) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_battle_check_arrows_pre ) { + bool (*preHookFunc) (struct map_session_data **sd); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_arrows_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_battle_check_arrows_pre[hIndex].func; + retVal___ = preHookFunc(&sd); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.battle.check_arrows(sd); + } + if( HPMHooks.count.HP_battle_check_arrows_post ) { + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd); + for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_arrows_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_battle_check_arrows_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sd); } } return retVal___; } struct Damage HP_battle_calc_weapon_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag) { int hIndex = 0; - struct Damage retVal___; - memset(&retVal___, '\0', sizeof(struct Damage)); + struct Damage retVal___ = { 0 }; if( HPMHooks.count.HP_battle_calc_weapon_attack_pre ) { - struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *wflag); + struct Damage (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *wflag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_weapon_attack_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &wflag); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &wflag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1286,10 +1313,10 @@ struct Damage HP_battle_calc_weapon_attack(struct block_list *src, struct block_ retVal___ = HPMHooks.source.battle.calc_weapon_attack(src, target, skill_id, skill_lv, wflag); } if( HPMHooks.count.HP_battle_calc_weapon_attack_post ) { - struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *wflag); + struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_weapon_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &wflag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, wflag); } } return retVal___; @@ -1298,11 +1325,11 @@ int HP_battle_delay_damage(int64 tick, int amotion, struct block_list *src, stru int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_delay_damage_pre ) { - int (*preHookFunc) (int64 *tick, int *amotion, struct block_list *src, struct block_list *target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects); + int (*preHookFunc) (int64 *tick, int *amotion, struct block_list **src, struct block_list **target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_delay_damage_pre[hIndex].func; - retVal___ = preHookFunc(&tick, &amotion, src, target, &attack_type, &skill_id, &skill_lv, &damage, &dmg_lv, &ddelay, &additional_effects); + retVal___ = preHookFunc(&tick, &amotion, &src, &target, &attack_type, &skill_id, &skill_lv, &damage, &dmg_lv, &ddelay, &additional_effects); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1313,10 +1340,10 @@ int HP_battle_delay_damage(int64 tick, int amotion, struct block_list *src, stru retVal___ = HPMHooks.source.battle.delay_damage(tick, amotion, src, target, attack_type, skill_id, skill_lv, damage, dmg_lv, ddelay, additional_effects); } if( HPMHooks.count.HP_battle_delay_damage_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, int *amotion, struct block_list *src, struct block_list *target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects); + int (*postHookFunc) (int retVal___, int64 tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int64 damage, enum damage_lv dmg_lv, int ddelay, bool additional_effects); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_delay_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &amotion, src, target, &attack_type, &skill_id, &skill_lv, &damage, &dmg_lv, &ddelay, &additional_effects); + retVal___ = postHookFunc(retVal___, tick, amotion, src, target, attack_type, skill_id, skill_lv, damage, dmg_lv, ddelay, additional_effects); } } return retVal___; @@ -1324,11 +1351,11 @@ int HP_battle_delay_damage(int64 tick, int amotion, struct block_list *src, stru void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss) { int hIndex = 0; if( HPMHooks.count.HP_battle_drain_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_drain_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_drain_pre[hIndex].func; - preHookFunc(sd, tbl, &rdamage, &ldamage, &race, &boss); + preHookFunc(&sd, &tbl, &rdamage, &ldamage, &race, &boss); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1339,10 +1366,10 @@ void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 HPMHooks.source.battle.drain(sd, tbl, rdamage, ldamage, race, boss); } if( HPMHooks.count.HP_battle_drain_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss); + void (*postHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_drain_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_drain_post[hIndex].func; - postHookFunc(sd, tbl, &rdamage, &ldamage, &race, &boss); + postHookFunc(sd, tbl, rdamage, ldamage, race, boss); } } return; @@ -1350,11 +1377,11 @@ void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 void HP_battle_reflect_damage(struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id) { int hIndex = 0; if( HPMHooks.count.HP_battle_reflect_damage_pre ) { - void (*preHookFunc) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 *skill_id); + void (*preHookFunc) (struct block_list **target, struct block_list **src, struct Damage **wd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_reflect_damage_pre[hIndex].func; - preHookFunc(target, src, wd, &skill_id); + preHookFunc(&target, &src, &wd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1365,10 +1392,10 @@ void HP_battle_reflect_damage(struct block_list *target, struct block_list *src, HPMHooks.source.battle.reflect_damage(target, src, wd, skill_id); } if( HPMHooks.count.HP_battle_reflect_damage_post ) { - void (*postHookFunc) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 *skill_id); + void (*postHookFunc) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_reflect_damage_post[hIndex].func; - postHookFunc(target, src, wd, &skill_id); + postHookFunc(target, src, wd, skill_id); } } return; @@ -1392,10 +1419,10 @@ int HP_battle_attr_ratio(int atk_elem, int def_type, int def_lv) { retVal___ = HPMHooks.source.battle.attr_ratio(atk_elem, def_type, def_lv); } if( HPMHooks.count.HP_battle_attr_ratio_post ) { - int (*postHookFunc) (int retVal___, int *atk_elem, int *def_type, int *def_lv); + int (*postHookFunc) (int retVal___, int atk_elem, int def_type, int def_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_ratio_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_attr_ratio_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &atk_elem, &def_type, &def_lv); + retVal___ = postHookFunc(retVal___, atk_elem, def_type, def_lv); } } return retVal___; @@ -1404,11 +1431,11 @@ int64 HP_battle_attr_fix(struct block_list *src, struct block_list *target, int6 int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_attr_fix_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *target, int64 *damage, int *atk_elem, int *def_type, int *def_lv); + int64 (*preHookFunc) (struct block_list **src, struct block_list **target, int64 *damage, int *atk_elem, int *def_type, int *def_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_fix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_attr_fix_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &damage, &atk_elem, &def_type, &def_lv); + retVal___ = preHookFunc(&src, &target, &damage, &atk_elem, &def_type, &def_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1419,10 +1446,10 @@ int64 HP_battle_attr_fix(struct block_list *src, struct block_list *target, int6 retVal___ = HPMHooks.source.battle.attr_fix(src, target, damage, atk_elem, def_type, def_lv); } if( HPMHooks.count.HP_battle_attr_fix_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, int64 *damage, int *atk_elem, int *def_type, int *def_lv); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, int64 damage, int atk_elem, int def_type, int def_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_fix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_attr_fix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &damage, &atk_elem, &def_type, &def_lv); + retVal___ = postHookFunc(retVal___, src, target, damage, atk_elem, def_type, def_lv); } } return retVal___; @@ -1431,11 +1458,11 @@ int64 HP_battle_calc_cardfix(int attack_type, struct block_list *src, struct blo int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_cardfix_pre ) { - int64 (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag); + int64 (*preHookFunc) (int *attack_type, struct block_list **src, struct block_list **target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_cardfix_pre[hIndex].func; - retVal___ = preHookFunc(&attack_type, src, target, &nk, &s_ele, &s_ele_, &damage, &left, &flag); + retVal___ = preHookFunc(&attack_type, &src, &target, &nk, &s_ele, &s_ele_, &damage, &left, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1446,10 +1473,10 @@ int64 HP_battle_calc_cardfix(int attack_type, struct block_list *src, struct blo retVal___ = HPMHooks.source.battle.calc_cardfix(attack_type, src, target, nk, s_ele, s_ele_, damage, left, flag); } if( HPMHooks.count.HP_battle_calc_cardfix_post ) { - int64 (*postHookFunc) (int64 retVal___, int *attack_type, struct block_list *src, struct block_list *target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag); + int64 (*postHookFunc) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int64 damage, int left, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_cardfix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &attack_type, src, target, &nk, &s_ele, &s_ele_, &damage, &left, &flag); + retVal___ = postHookFunc(retVal___, attack_type, src, target, nk, s_ele, s_ele_, damage, left, flag); } } return retVal___; @@ -1458,11 +1485,11 @@ int64 HP_battle_calc_cardfix2(struct block_list *src, struct block_list *bl, int int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_cardfix2_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, int64 *damage, int *s_ele, int *nk, int *flag); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, int64 *damage, int *s_ele, int *nk, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_cardfix2_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &damage, &s_ele, &nk, &flag); + retVal___ = preHookFunc(&src, &bl, &damage, &s_ele, &nk, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1473,10 +1500,10 @@ int64 HP_battle_calc_cardfix2(struct block_list *src, struct block_list *bl, int retVal___ = HPMHooks.source.battle.calc_cardfix2(src, bl, damage, s_ele, nk, flag); } if( HPMHooks.count.HP_battle_calc_cardfix2_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 *damage, int *s_ele, int *nk, int *flag); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int s_ele, int nk, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_cardfix2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &damage, &s_ele, &nk, &flag); + retVal___ = postHookFunc(retVal___, src, bl, damage, s_ele, nk, flag); } } return retVal___; @@ -1485,11 +1512,11 @@ int64 HP_battle_calc_elefix(struct block_list *src, struct block_list *target, u int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_elefix_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag); + int64 (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_elefix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_elefix_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &damage, &nk, &n_ele, &s_ele, &s_ele_, &left, &flag); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &damage, &nk, &n_ele, &s_ele, &s_ele_, &left, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1500,10 +1527,10 @@ int64 HP_battle_calc_elefix(struct block_list *src, struct block_list *target, u retVal___ = HPMHooks.source.battle.calc_elefix(src, target, skill_id, skill_lv, damage, nk, n_ele, s_ele, s_ele_, left, flag); } if( HPMHooks.count.HP_battle_calc_elefix_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int nk, int n_ele, int s_ele, int s_ele_, bool left, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_elefix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_elefix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &damage, &nk, &n_ele, &s_ele, &s_ele_, &left, &flag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, damage, nk, n_ele, s_ele, s_ele_, left, flag); } } return retVal___; @@ -1512,11 +1539,11 @@ int64 HP_battle_calc_masteryfix(struct block_list *src, struct block_list *targe int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_masteryfix_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); + int64 (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &damage, &div, &left, &weapon); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &damage, &div, &left, &weapon); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1527,10 +1554,10 @@ int64 HP_battle_calc_masteryfix(struct block_list *src, struct block_list *targe retVal___ = HPMHooks.source.battle.calc_masteryfix(src, target, skill_id, skill_lv, damage, div, left, weapon); } if( HPMHooks.count.HP_battle_calc_masteryfix_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int div, bool left, bool weapon); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &damage, &div, &left, &weapon); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, damage, div, left, weapon); } } return retVal___; @@ -1539,11 +1566,11 @@ int HP_battle_calc_chorusbonus(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_calc_chorusbonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_chorusbonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_chorusbonus_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1566,11 +1593,11 @@ int HP_battle_calc_skillratio(int attack_type, struct block_list *src, struct bl int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_calc_skillratio_pre ) { - int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); + int (*preHookFunc) (int *attack_type, struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_pre[hIndex].func; - retVal___ = preHookFunc(&attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag); + retVal___ = preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &skillratio, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1581,10 +1608,10 @@ int HP_battle_calc_skillratio(int attack_type, struct block_list *src, struct bl retVal___ = HPMHooks.source.battle.calc_skillratio(attack_type, src, target, skill_id, skill_lv, skillratio, flag); } if( HPMHooks.count.HP_battle_calc_skillratio_post ) { - int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); + int (*postHookFunc) (int retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag); + retVal___ = postHookFunc(retVal___, attack_type, src, target, skill_id, skill_lv, skillratio, flag); } } return retVal___; @@ -1593,11 +1620,11 @@ int64 HP_battle_calc_sizefix(struct map_session_data *sd, int64 damage, int type int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_sizefix_pre ) { - int64 (*preHookFunc) (struct map_session_data *sd, int64 *damage, int *type, int *size, bool *ignore); + int64 (*preHookFunc) (struct map_session_data **sd, int64 *damage, int *type, int *size, bool *ignore); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_sizefix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_sizefix_pre[hIndex].func; - retVal___ = preHookFunc(sd, &damage, &type, &size, &ignore); + retVal___ = preHookFunc(&sd, &damage, &type, &size, &ignore); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1608,10 +1635,10 @@ int64 HP_battle_calc_sizefix(struct map_session_data *sd, int64 damage, int type retVal___ = HPMHooks.source.battle.calc_sizefix(sd, damage, type, size, ignore); } if( HPMHooks.count.HP_battle_calc_sizefix_post ) { - int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, int64 *damage, int *type, int *size, bool *ignore); + int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, int64 damage, int type, int size, bool ignore); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_sizefix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_sizefix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &damage, &type, &size, &ignore); + retVal___ = postHookFunc(retVal___, sd, damage, type, size, ignore); } } return retVal___; @@ -1620,11 +1647,11 @@ int64 HP_battle_calc_weapon_damage(struct block_list *src, struct block_list *bl int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_weapon_damage_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk *watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk **watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_weapon_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, watk, &nk, &n_ele, &s_ele, &s_ele_, &size, &type, &flag, &flag2); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &watk, &nk, &n_ele, &s_ele, &s_ele_, &size, &type, &flag, &flag2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1635,10 +1662,10 @@ int64 HP_battle_calc_weapon_damage(struct block_list *src, struct block_list *bl retVal___ = HPMHooks.source.battle.calc_weapon_damage(src, bl, skill_id, skill_lv, watk, nk, n_ele, s_ele, s_ele_, size, type, flag, flag2); } if( HPMHooks.count.HP_battle_calc_weapon_damage_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk *watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_weapon_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, watk, &nk, &n_ele, &s_ele, &s_ele_, &size, &type, &flag, &flag2); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, watk, nk, n_ele, s_ele, s_ele_, size, type, flag, flag2); } } return retVal___; @@ -1647,11 +1674,11 @@ int64 HP_battle_calc_defense(int attack_type, struct block_list *src, struct blo int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_defense_pre ) { - int64 (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef); + int64 (*preHookFunc) (int *attack_type, struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_defense_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_defense_pre[hIndex].func; - retVal___ = preHookFunc(&attack_type, src, target, &skill_id, &skill_lv, &damage, &flag, &pdef); + retVal___ = preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &damage, &flag, &pdef); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1662,10 +1689,10 @@ int64 HP_battle_calc_defense(int attack_type, struct block_list *src, struct blo retVal___ = HPMHooks.source.battle.calc_defense(attack_type, src, target, skill_id, skill_lv, damage, flag, pdef); } if( HPMHooks.count.HP_battle_calc_defense_post ) { - int64 (*postHookFunc) (int64 retVal___, int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef); + int64 (*postHookFunc) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_defense_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_defense_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &attack_type, src, target, &skill_id, &skill_lv, &damage, &flag, &pdef); + retVal___ = postHookFunc(retVal___, attack_type, src, target, skill_id, skill_lv, damage, flag, pdef); } } return retVal___; @@ -1674,11 +1701,11 @@ struct block_list* HP_battle_get_master(struct block_list *src) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_battle_get_master_pre ) { - struct block_list* (*preHookFunc) (struct block_list *src); + struct block_list* (*preHookFunc) (struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_master_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_master_pre[hIndex].func; - retVal___ = preHookFunc(src); + retVal___ = preHookFunc(&src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1701,11 +1728,11 @@ struct block_list* HP_battle_get_targeted(struct block_list *target) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_battle_get_targeted_pre ) { - struct block_list* (*preHookFunc) (struct block_list *target); + struct block_list* (*preHookFunc) (struct block_list **target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_targeted_pre[hIndex].func; - retVal___ = preHookFunc(target); + retVal___ = preHookFunc(&target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1728,11 +1755,11 @@ struct block_list* HP_battle_get_enemy(struct block_list *target, int type, int int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_battle_get_enemy_pre ) { - struct block_list* (*preHookFunc) (struct block_list *target, int *type, int *range); + struct block_list* (*preHookFunc) (struct block_list **target, int *type, int *range); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_enemy_pre[hIndex].func; - retVal___ = preHookFunc(target, &type, &range); + retVal___ = preHookFunc(&target, &type, &range); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1743,10 +1770,10 @@ struct block_list* HP_battle_get_enemy(struct block_list *target, int type, int retVal___ = HPMHooks.source.battle.get_enemy(target, type, range); } if( HPMHooks.count.HP_battle_get_enemy_post ) { - struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target, int *type, int *range); + struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target, int type, int range); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_get_enemy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, target, &type, &range); + retVal___ = postHookFunc(retVal___, target, type, range); } } return retVal___; @@ -1755,11 +1782,11 @@ int HP_battle_get_target(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_get_target_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_target_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_target_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1782,11 +1809,11 @@ int HP_battle_get_current_skill(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_get_current_skill_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_current_skill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_current_skill_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1824,10 +1851,10 @@ bool HP_battle_check_undead(int race, int element) { retVal___ = HPMHooks.source.battle.check_undead(race, element); } if( HPMHooks.count.HP_battle_check_undead_post ) { - bool (*postHookFunc) (bool retVal___, int *race, int *element); + bool (*postHookFunc) (bool retVal___, int race, int element); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_undead_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_check_undead_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &race, &element); + retVal___ = postHookFunc(retVal___, race, element); } } return retVal___; @@ -1836,11 +1863,11 @@ int HP_battle_check_target(struct block_list *src, struct block_list *target, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_check_target_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_target_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_check_target_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &flag); + retVal___ = preHookFunc(&src, &target, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1851,10 +1878,10 @@ int HP_battle_check_target(struct block_list *src, struct block_list *target, in retVal___ = HPMHooks.source.battle.check_target(src, target, flag); } if( HPMHooks.count.HP_battle_check_target_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_target_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_check_target_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &flag); + retVal___ = postHookFunc(retVal___, src, target, flag); } } return retVal___; @@ -1863,11 +1890,11 @@ bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int ra int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_battle_check_range_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, int *range); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, int *range); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_range_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_check_range_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &range); + retVal___ = preHookFunc(&src, &bl, &range); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1878,10 +1905,10 @@ bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int ra retVal___ = HPMHooks.source.battle.check_range(src, bl, range); } if( HPMHooks.count.HP_battle_check_range_post ) { - bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, int *range); + bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, int range); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_range_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_check_range_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &range); + retVal___ = postHookFunc(retVal___, src, bl, range); } } return retVal___; @@ -1889,11 +1916,11 @@ bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int ra void HP_battle_consume_ammo(struct map_session_data *sd, int skill_id, int lv) { int hIndex = 0; if( HPMHooks.count.HP_battle_consume_ammo_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *lv); + void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_consume_ammo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_consume_ammo_pre[hIndex].func; - preHookFunc(sd, &skill_id, &lv); + preHookFunc(&sd, &skill_id, &lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -1904,10 +1931,10 @@ void HP_battle_consume_ammo(struct map_session_data *sd, int skill_id, int lv) { HPMHooks.source.battle.consume_ammo(sd, skill_id, lv); } if( HPMHooks.count.HP_battle_consume_ammo_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *lv); + void (*postHookFunc) (struct map_session_data *sd, int skill_id, int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_consume_ammo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_consume_ammo_post[hIndex].func; - postHookFunc(sd, &skill_id, &lv); + postHookFunc(sd, skill_id, lv); } } return; @@ -1916,12 +1943,12 @@ int HP_battle_get_targeted_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_get_targeted_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_battle_get_targeted_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -1949,12 +1976,12 @@ int HP_battle_get_enemy_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_get_enemy_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_battle_get_enemy_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -1982,12 +2009,12 @@ int HP_battle_get_enemy_area_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_get_enemy_area_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_battle_get_enemy_area_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -2030,10 +2057,10 @@ int HP_battle_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.battle.delay_damage_sub(tid, tick, id, data); } if( HPMHooks.count.HP_battle_delay_damage_sub_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_delay_damage_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -2042,11 +2069,11 @@ int HP_battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_blewcount_bonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_blewcount_bonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_blewcount_bonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2057,10 +2084,10 @@ int HP_battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.battle.blewcount_bonus(sd, skill_id); } if( HPMHooks.count.HP_battle_blewcount_bonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_blewcount_bonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_blewcount_bonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -2069,11 +2096,11 @@ int HP_battle_range_type(struct block_list *src, struct block_list *target, uint int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_range_type_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_range_type_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_range_type_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2084,10 +2111,10 @@ int HP_battle_range_type(struct block_list *src, struct block_list *target, uint retVal___ = HPMHooks.source.battle.range_type(src, target, skill_id, skill_lv); } if( HPMHooks.count.HP_battle_range_type_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_range_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_range_type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv); } } return retVal___; @@ -2096,11 +2123,11 @@ int64 HP_battle_calc_base_damage(struct block_list *src, struct block_list *bl, int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_base_damage_pre ) { - int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2); + int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_base_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &nk, &n_ele, &s_ele, &s_ele_, &type, &flag, &flag2); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &nk, &n_ele, &s_ele, &s_ele_, &type, &flag, &flag2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2111,10 +2138,10 @@ int64 HP_battle_calc_base_damage(struct block_list *src, struct block_list *bl, retVal___ = HPMHooks.source.battle.calc_base_damage(src, bl, skill_id, skill_lv, nk, n_ele, s_ele, s_ele_, type, flag, flag2); } if( HPMHooks.count.HP_battle_calc_base_damage_post ) { - int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2); + int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_base_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &nk, &n_ele, &s_ele, &s_ele_, &type, &flag, &flag2); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, nk, n_ele, s_ele, s_ele_, type, flag, flag2); } } return retVal___; @@ -2123,11 +2150,11 @@ int64 HP_battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa, int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_calc_base_damage2_pre ) { - int64 (*preHookFunc) (struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short *t_size, struct map_session_data *sd, int *flag); + int64 (*preHookFunc) (struct status_data **st, struct weapon_atk **wa, struct status_change **sc, unsigned short *t_size, struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_base_damage2_pre[hIndex].func; - retVal___ = preHookFunc(st, wa, sc, &t_size, sd, &flag); + retVal___ = preHookFunc(&st, &wa, &sc, &t_size, &sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2138,24 +2165,23 @@ int64 HP_battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa, retVal___ = HPMHooks.source.battle.calc_base_damage2(st, wa, sc, t_size, sd, flag); } if( HPMHooks.count.HP_battle_calc_base_damage2_post ) { - int64 (*postHookFunc) (int64 retVal___, struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short *t_size, struct map_session_data *sd, int *flag); + int64 (*postHookFunc) (int64 retVal___, struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_base_damage2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, st, wa, sc, &t_size, sd, &flag); + retVal___ = postHookFunc(retVal___, st, wa, sc, t_size, sd, flag); } } return retVal___; } struct Damage HP_battle_calc_misc_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) { int hIndex = 0; - struct Damage retVal___; - memset(&retVal___, '\0', sizeof(struct Damage)); + struct Damage retVal___ = { 0 }; if( HPMHooks.count.HP_battle_calc_misc_attack_pre ) { - struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag); + struct Damage (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *mflag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &mflag); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &mflag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2166,24 +2192,23 @@ struct Damage HP_battle_calc_misc_attack(struct block_list *src, struct block_li retVal___ = HPMHooks.source.battle.calc_misc_attack(src, target, skill_id, skill_lv, mflag); } if( HPMHooks.count.HP_battle_calc_misc_attack_post ) { - struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag); + struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &mflag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, mflag); } } return retVal___; } struct Damage HP_battle_calc_magic_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) { int hIndex = 0; - struct Damage retVal___; - memset(&retVal___, '\0', sizeof(struct Damage)); + struct Damage retVal___ = { 0 }; if( HPMHooks.count.HP_battle_calc_magic_attack_pre ) { - struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag); + struct Damage (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int *mflag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_magic_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_magic_attack_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &mflag); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &mflag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2194,10 +2219,10 @@ struct Damage HP_battle_calc_magic_attack(struct block_list *src, struct block_l retVal___ = HPMHooks.source.battle.calc_magic_attack(src, target, skill_id, skill_lv, mflag); } if( HPMHooks.count.HP_battle_calc_magic_attack_post ) { - struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag); + struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_magic_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_magic_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &mflag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, mflag); } } return retVal___; @@ -2221,10 +2246,10 @@ int HP_battle_adjust_skill_damage(int m, unsigned short skill_id) { retVal___ = HPMHooks.source.battle.adjust_skill_damage(m, skill_id); } if( HPMHooks.count.HP_battle_adjust_skill_damage_post ) { - int (*postHookFunc) (int retVal___, int *m, unsigned short *skill_id); + int (*postHookFunc) (int retVal___, int m, unsigned short skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_adjust_skill_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_adjust_skill_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, &skill_id); + retVal___ = postHookFunc(retVal___, m, skill_id); } } return retVal___; @@ -2233,11 +2258,11 @@ int64 HP_battle_add_mastery(struct map_session_data *sd, struct block_list *targ int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_battle_add_mastery_pre ) { - int64 (*preHookFunc) (struct map_session_data *sd, struct block_list *target, int64 *dmg, int *type); + int64 (*preHookFunc) (struct map_session_data **sd, struct block_list **target, int64 *dmg, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_add_mastery_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_add_mastery_pre[hIndex].func; - retVal___ = preHookFunc(sd, target, &dmg, &type); + retVal___ = preHookFunc(&sd, &target, &dmg, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2248,10 +2273,10 @@ int64 HP_battle_add_mastery(struct map_session_data *sd, struct block_list *targ retVal___ = HPMHooks.source.battle.add_mastery(sd, target, dmg, type); } if( HPMHooks.count.HP_battle_add_mastery_post ) { - int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, struct block_list *target, int64 *dmg, int *type); + int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, struct block_list *target, int64 dmg, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_add_mastery_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_add_mastery_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, target, &dmg, &type); + retVal___ = postHookFunc(retVal___, sd, target, dmg, type); } } return retVal___; @@ -2275,10 +2300,10 @@ int HP_battle_calc_drain(int64 damage, int rate, int per) { retVal___ = HPMHooks.source.battle.calc_drain(damage, rate, per); } if( HPMHooks.count.HP_battle_calc_drain_post ) { - int (*postHookFunc) (int retVal___, int64 *damage, int *rate, int *per); + int (*postHookFunc) (int retVal___, int64 damage, int rate, int per); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_drain_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_calc_drain_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &damage, &rate, &per); + retVal___ = postHookFunc(retVal___, damage, rate, per); } } return retVal___; @@ -2287,11 +2312,11 @@ int HP_battle_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2340,11 +2365,11 @@ int HP_battle_config_set_value(const char *w1, const char *w2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_config_set_value_pre ) { - int (*preHookFunc) (const char *w1, const char *w2); + int (*preHookFunc) (const char **w1, const char **w2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_config_set_value_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2); + retVal___ = preHookFunc(&w1, &w2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2367,11 +2392,11 @@ bool HP_battle_config_get_value(const char *w1, int *value) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_battle_config_get_value_pre ) { - bool (*preHookFunc) (const char *w1, int *value); + bool (*preHookFunc) (const char **w1, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_get_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_config_get_value_pre[hIndex].func; - retVal___ = preHookFunc(w1, value); + retVal___ = preHookFunc(&w1, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2420,11 +2445,11 @@ struct block_list* HP_battle_get_enemy_area(struct block_list *src, int x, int y int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_battle_get_enemy_area_pre ) { - struct block_list* (*preHookFunc) (struct block_list *src, int *x, int *y, int *range, int *type, int *ignore_id); + struct block_list* (*preHookFunc) (struct block_list **src, int *x, int *y, int *range, int *type, int *ignore_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_get_enemy_area_pre[hIndex].func; - retVal___ = preHookFunc(src, &x, &y, &range, &type, &ignore_id); + retVal___ = preHookFunc(&src, &x, &y, &range, &type, &ignore_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2435,10 +2460,10 @@ struct block_list* HP_battle_get_enemy_area(struct block_list *src, int x, int y retVal___ = HPMHooks.source.battle.get_enemy_area(src, x, y, range, type, ignore_id); } if( HPMHooks.count.HP_battle_get_enemy_area_post ) { - struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src, int *x, int *y, int *range, int *type, int *ignore_id); + struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src, int x, int y, int range, int type, int ignore_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_battle_get_enemy_area_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &x, &y, &range, &type, &ignore_id); + retVal___ = postHookFunc(retVal___, src, x, y, range, type, ignore_id); } } return retVal___; @@ -2447,12 +2472,12 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_battle_damage_area_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_damage_area_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_battle_damage_area_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -2479,11 +2504,11 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) { void HP_battle_calc_masteryfix_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon) { int hIndex = 0; if( HPMHooks.count.HP_battle_calc_masteryfix_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon); + void (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int64 **damage, int **div, bool **left, bool **weapon); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_unknown_pre[hIndex].func; - preHookFunc(src, target, skill_id, skill_lv, damage, div, left, weapon); + preHookFunc(&src, &target, &skill_id, &skill_lv, &damage, &div, &left, &weapon); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2505,11 +2530,11 @@ void HP_battle_calc_masteryfix_unknown(struct block_list *src, struct block_list void HP_battle_calc_skillratio_magic_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) { int hIndex = 0; if( HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **skillratio, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_magic_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag); + preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &skillratio, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2531,11 +2556,11 @@ void HP_battle_calc_skillratio_magic_unknown(int *attack_type, struct block_list void HP_battle_calc_skillratio_weapon_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) { int hIndex = 0; if( HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **skillratio, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_weapon_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag); + preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &skillratio, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2557,11 +2582,11 @@ void HP_battle_calc_skillratio_weapon_unknown(int *attack_type, struct block_lis void HP_battle_calc_misc_attack_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md) { int hIndex = 0; if( HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md); + void (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **mflag, struct Damage **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_unknown_pre[hIndex].func; - preHookFunc(src, target, skill_id, skill_lv, mflag, md); + preHookFunc(&src, &target, &skill_id, &skill_lv, &mflag, &md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2599,10 +2624,10 @@ void HP_bg_init(bool minimal) { HPMHooks.source.bg.init(minimal); } if( HPMHooks.count.HP_bg_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -2637,11 +2662,11 @@ struct bg_arena* HP_bg_name2arena(const char *name) { int hIndex = 0; struct bg_arena* retVal___ = NULL; if( HPMHooks.count.HP_bg_name2arena_pre ) { - struct bg_arena* (*preHookFunc) (const char *name); + struct bg_arena* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_name2arena_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_name2arena_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2663,11 +2688,11 @@ struct bg_arena* HP_bg_name2arena(const char *name) { void HP_bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) { int hIndex = 0; if( HPMHooks.count.HP_bg_queue_add_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type); + void (*preHookFunc) (struct map_session_data **sd, struct bg_arena **arena, enum bg_queue_types *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_queue_add_pre[hIndex].func; - preHookFunc(sd, arena, &type); + preHookFunc(&sd, &arena, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2678,10 +2703,10 @@ void HP_bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum b HPMHooks.source.bg.queue_add(sd, arena, type); } if( HPMHooks.count.HP_bg_queue_add_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type); + void (*postHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_queue_add_post[hIndex].func; - postHookFunc(sd, arena, &type); + postHookFunc(sd, arena, type); } } return; @@ -2690,11 +2715,11 @@ enum BATTLEGROUNDS_QUEUE_ACK HP_bg_can_queue(struct map_session_data *sd, struct int hIndex = 0; enum BATTLEGROUNDS_QUEUE_ACK retVal___ = BGQA_SUCCESS; if( HPMHooks.count.HP_bg_can_queue_pre ) { - enum BATTLEGROUNDS_QUEUE_ACK (*preHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type); + enum BATTLEGROUNDS_QUEUE_ACK (*preHookFunc) (struct map_session_data **sd, struct bg_arena **arena, enum bg_queue_types *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_can_queue_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_can_queue_pre[hIndex].func; - retVal___ = preHookFunc(sd, arena, &type); + retVal___ = preHookFunc(&sd, &arena, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2705,10 +2730,10 @@ enum BATTLEGROUNDS_QUEUE_ACK HP_bg_can_queue(struct map_session_data *sd, struct retVal___ = HPMHooks.source.bg.can_queue(sd, arena, type); } if( HPMHooks.count.HP_bg_can_queue_post ) { - enum BATTLEGROUNDS_QUEUE_ACK (*postHookFunc) (enum BATTLEGROUNDS_QUEUE_ACK retVal___, struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type); + enum BATTLEGROUNDS_QUEUE_ACK (*postHookFunc) (enum BATTLEGROUNDS_QUEUE_ACK retVal___, struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_can_queue_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_can_queue_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, arena, &type); + retVal___ = postHookFunc(retVal___, sd, arena, type); } } return retVal___; @@ -2732,10 +2757,10 @@ int HP_bg_id2pos(int queue_id, int account_id) { retVal___ = HPMHooks.source.bg.id2pos(queue_id, account_id); } if( HPMHooks.count.HP_bg_id2pos_post ) { - int (*postHookFunc) (int retVal___, int *queue_id, int *account_id); + int (*postHookFunc) (int retVal___, int queue_id, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_id2pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_id2pos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &queue_id, &account_id); + retVal___ = postHookFunc(retVal___, queue_id, account_id); } } return retVal___; @@ -2743,11 +2768,11 @@ int HP_bg_id2pos(int queue_id, int account_id) { void HP_bg_queue_pc_cleanup(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_bg_queue_pc_cleanup_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pc_cleanup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_queue_pc_cleanup_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2769,11 +2794,11 @@ void HP_bg_queue_pc_cleanup(struct map_session_data *sd) { void HP_bg_begin(struct bg_arena *arena) { int hIndex = 0; if( HPMHooks.count.HP_bg_begin_pre ) { - void (*preHookFunc) (struct bg_arena *arena); + void (*preHookFunc) (struct bg_arena **arena); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_begin_pre[hIndex].func; - preHookFunc(arena); + preHookFunc(&arena); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2811,10 +2836,10 @@ int HP_bg_begin_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.bg.begin_timer(tid, tick, id, data); } if( HPMHooks.count.HP_bg_begin_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_begin_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -2822,11 +2847,11 @@ int HP_bg_begin_timer(int tid, int64 tick, int id, intptr_t data) { void HP_bg_queue_pregame(struct bg_arena *arena) { int hIndex = 0; if( HPMHooks.count.HP_bg_queue_pregame_pre ) { - void (*preHookFunc) (struct bg_arena *arena); + void (*preHookFunc) (struct bg_arena **arena); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pregame_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_queue_pregame_pre[hIndex].func; - preHookFunc(arena); + preHookFunc(&arena); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2864,10 +2889,10 @@ int HP_bg_fillup_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.bg.fillup_timer(tid, tick, id, data); } if( HPMHooks.count.HP_bg_fillup_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_fillup_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_fillup_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -2875,11 +2900,11 @@ int HP_bg_fillup_timer(int tid, int64 tick, int id, intptr_t data) { void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd, bool response) { int hIndex = 0; if( HPMHooks.count.HP_bg_queue_ready_ack_pre ) { - void (*preHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool *response); + void (*preHookFunc) (struct bg_arena **arena, struct map_session_data **sd, bool *response); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_ready_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_queue_ready_ack_pre[hIndex].func; - preHookFunc(arena, sd, &response); + preHookFunc(&arena, &sd, &response); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2890,10 +2915,10 @@ void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd, HPMHooks.source.bg.queue_ready_ack(arena, sd, response); } if( HPMHooks.count.HP_bg_queue_ready_ack_post ) { - void (*postHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool *response); + void (*postHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool response); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_ready_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_queue_ready_ack_post[hIndex].func; - postHookFunc(arena, sd, &response); + postHookFunc(arena, sd, response); } } return; @@ -2901,11 +2926,11 @@ void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd, void HP_bg_match_over(struct bg_arena *arena, bool canceled) { int hIndex = 0; if( HPMHooks.count.HP_bg_match_over_pre ) { - void (*preHookFunc) (struct bg_arena *arena, bool *canceled); + void (*preHookFunc) (struct bg_arena **arena, bool *canceled); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_match_over_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_match_over_pre[hIndex].func; - preHookFunc(arena, &canceled); + preHookFunc(&arena, &canceled); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2916,10 +2941,10 @@ void HP_bg_match_over(struct bg_arena *arena, bool canceled) { HPMHooks.source.bg.match_over(arena, canceled); } if( HPMHooks.count.HP_bg_match_over_post ) { - void (*postHookFunc) (struct bg_arena *arena, bool *canceled); + void (*postHookFunc) (struct bg_arena *arena, bool canceled); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_match_over_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_match_over_post[hIndex].func; - postHookFunc(arena, &canceled); + postHookFunc(arena, canceled); } } return; @@ -2927,11 +2952,11 @@ void HP_bg_match_over(struct bg_arena *arena, bool canceled) { void HP_bg_queue_check(struct bg_arena *arena) { int hIndex = 0; if( HPMHooks.count.HP_bg_queue_check_pre ) { - void (*preHookFunc) (struct bg_arena *arena); + void (*preHookFunc) (struct bg_arena **arena); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_queue_check_pre[hIndex].func; - preHookFunc(arena); + preHookFunc(&arena); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -2969,10 +2994,10 @@ struct battleground_data* HP_bg_team_search(int bg_id) { retVal___ = HPMHooks.source.bg.team_search(bg_id); } if( HPMHooks.count.HP_bg_team_search_post ) { - struct battleground_data* (*postHookFunc) (struct battleground_data* retVal___, int *bg_id); + struct battleground_data* (*postHookFunc) (struct battleground_data* retVal___, int bg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_team_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &bg_id); + retVal___ = postHookFunc(retVal___, bg_id); } } return retVal___; @@ -2981,11 +3006,11 @@ struct map_session_data* HP_bg_getavailablesd(struct battleground_data *bgd) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_bg_getavailablesd_pre ) { - struct map_session_data* (*preHookFunc) (struct battleground_data *bgd); + struct map_session_data* (*preHookFunc) (struct battleground_data **bgd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_getavailablesd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_getavailablesd_pre[hIndex].func; - retVal___ = preHookFunc(bgd); + retVal___ = preHookFunc(&bgd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3023,10 +3048,10 @@ bool HP_bg_team_delete(int bg_id) { retVal___ = HPMHooks.source.bg.team_delete(bg_id); } if( HPMHooks.count.HP_bg_team_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *bg_id); + bool (*postHookFunc) (bool retVal___, int bg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_team_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &bg_id); + retVal___ = postHookFunc(retVal___, bg_id); } } return retVal___; @@ -3050,10 +3075,10 @@ bool HP_bg_team_warp(int bg_id, unsigned short map_index, short x, short y) { retVal___ = HPMHooks.source.bg.team_warp(bg_id, map_index, x, y); } if( HPMHooks.count.HP_bg_team_warp_post ) { - bool (*postHookFunc) (bool retVal___, int *bg_id, unsigned short *map_index, short *x, short *y); + bool (*postHookFunc) (bool retVal___, int bg_id, unsigned short map_index, short x, short y); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_warp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_team_warp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &bg_id, &map_index, &x, &y); + retVal___ = postHookFunc(retVal___, bg_id, map_index, x, y); } } return retVal___; @@ -3061,11 +3086,11 @@ bool HP_bg_team_warp(int bg_id, unsigned short map_index, short x, short y) { void HP_bg_send_dot_remove(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_bg_send_dot_remove_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_dot_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_send_dot_remove_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3088,11 +3113,11 @@ bool HP_bg_team_join(int bg_id, struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_bg_team_join_pre ) { - bool (*preHookFunc) (int *bg_id, struct map_session_data *sd); + bool (*preHookFunc) (int *bg_id, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_join_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_team_join_pre[hIndex].func; - retVal___ = preHookFunc(&bg_id, sd); + retVal___ = preHookFunc(&bg_id, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3103,10 +3128,10 @@ bool HP_bg_team_join(int bg_id, struct map_session_data *sd) { retVal___ = HPMHooks.source.bg.team_join(bg_id, sd); } if( HPMHooks.count.HP_bg_team_join_post ) { - bool (*postHookFunc) (bool retVal___, int *bg_id, struct map_session_data *sd); + bool (*postHookFunc) (bool retVal___, int bg_id, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_join_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_team_join_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &bg_id, sd); + retVal___ = postHookFunc(retVal___, bg_id, sd); } } return retVal___; @@ -3115,11 +3140,11 @@ int HP_bg_team_leave(struct map_session_data *sd, enum bg_team_leave_type flag) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_bg_team_leave_pre ) { - int (*preHookFunc) (struct map_session_data *sd, enum bg_team_leave_type *flag); + int (*preHookFunc) (struct map_session_data **sd, enum bg_team_leave_type *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_team_leave_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3130,10 +3155,10 @@ int HP_bg_team_leave(struct map_session_data *sd, enum bg_team_leave_type flag) retVal___ = HPMHooks.source.bg.team_leave(sd, flag); } if( HPMHooks.count.HP_bg_team_leave_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum bg_team_leave_type *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum bg_team_leave_type flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_team_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -3142,11 +3167,11 @@ bool HP_bg_member_respawn(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_bg_member_respawn_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_member_respawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_member_respawn_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3169,11 +3194,11 @@ int HP_bg_create(unsigned short map_index, short rx, short ry, const char *ev, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_bg_create_pre ) { - int (*preHookFunc) (unsigned short *map_index, short *rx, short *ry, const char *ev, const char *dev); + int (*preHookFunc) (unsigned short *map_index, short *rx, short *ry, const char **ev, const char **dev); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_create_pre[hIndex].func; - retVal___ = preHookFunc(&map_index, &rx, &ry, ev, dev); + retVal___ = preHookFunc(&map_index, &rx, &ry, &ev, &dev); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3184,10 +3209,10 @@ int HP_bg_create(unsigned short map_index, short rx, short ry, const char *ev, c retVal___ = HPMHooks.source.bg.create(map_index, rx, ry, ev, dev); } if( HPMHooks.count.HP_bg_create_post ) { - int (*postHookFunc) (int retVal___, unsigned short *map_index, short *rx, short *ry, const char *ev, const char *dev); + int (*postHookFunc) (int retVal___, unsigned short map_index, short rx, short ry, const char *ev, const char *dev); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map_index, &rx, &ry, ev, dev); + retVal___ = postHookFunc(retVal___, map_index, rx, ry, ev, dev); } } return retVal___; @@ -3196,11 +3221,11 @@ int HP_bg_team_get_id(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_bg_team_get_id_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_get_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_team_get_id_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3219,15 +3244,15 @@ int HP_bg_team_get_id(struct block_list *bl) { } return retVal___; } -bool HP_bg_send_message(struct map_session_data *sd, const char *mes, int len) { +bool HP_bg_send_message(struct map_session_data *sd, const char *mes) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_bg_send_message_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len); + bool (*preHookFunc) (struct map_session_data **sd, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_send_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, mes, &len); + retVal___ = preHookFunc(&sd, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3235,13 +3260,13 @@ bool HP_bg_send_message(struct map_session_data *sd, const char *mes, int len) { } } { - retVal___ = HPMHooks.source.bg.send_message(sd, mes, len); + retVal___ = HPMHooks.source.bg.send_message(sd, mes); } if( HPMHooks.count.HP_bg_send_message_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *mes, int *len); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_send_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, mes, &len); + retVal___ = postHookFunc(retVal___, sd, mes); } } return retVal___; @@ -3250,12 +3275,12 @@ int HP_bg_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_bg_send_xy_timer_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_bg_send_xy_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3269,11 +3294,11 @@ int HP_bg_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_bg_send_xy_timer_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3298,10 +3323,10 @@ int HP_bg_send_xy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.bg.send_xy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_bg_send_xy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3325,10 +3350,10 @@ int HP_bg_afk_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.bg.afk_timer(tid, tick, id, data); } if( HPMHooks.count.HP_bg_afk_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_afk_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_bg_afk_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -3337,12 +3362,12 @@ int HP_bg_team_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_bg_team_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_bg_team_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -3356,11 +3381,11 @@ int HP_bg_team_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_bg_team_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_bg_team_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -3370,11 +3395,11 @@ enum bg_queue_types HP_bg_str2teamtype(const char *str) { int hIndex = 0; enum bg_queue_types retVal___ = BGQT_INVALID; if( HPMHooks.count.HP_bg_str2teamtype_pre ) { - enum bg_queue_types (*preHookFunc) (const char *str); + enum bg_queue_types (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_str2teamtype_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_bg_str2teamtype_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3424,11 +3449,11 @@ bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_buyingstore_setup_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned char *slots); + bool (*preHookFunc) (struct map_session_data **sd, unsigned char *slots); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_setup_pre[hIndex].func; - retVal___ = preHookFunc(sd, &slots); + retVal___ = preHookFunc(&sd, &slots); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3439,10 +3464,10 @@ bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) { retVal___ = HPMHooks.source.buyingstore.setup(sd, slots); } if( HPMHooks.count.HP_buyingstore_setup_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char *slots); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char slots); for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_buyingstore_setup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &slots); + retVal___ = postHookFunc(retVal___, sd, slots); } } return retVal___; @@ -3450,11 +3475,11 @@ bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) { void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count) { int hIndex = 0; if( HPMHooks.count.HP_buyingstore_create_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *zenylimit, unsigned char *result, const char *storename, const uint8 *itemlist, unsigned int *count); + void (*preHookFunc) (struct map_session_data **sd, int *zenylimit, unsigned char *result, const char **storename, const uint8 **itemlist, unsigned int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_create_pre[hIndex].func; - preHookFunc(sd, &zenylimit, &result, storename, itemlist, &count); + preHookFunc(&sd, &zenylimit, &result, &storename, &itemlist, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3465,10 +3490,10 @@ void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned HPMHooks.source.buyingstore.create(sd, zenylimit, result, storename, itemlist, count); } if( HPMHooks.count.HP_buyingstore_create_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *zenylimit, unsigned char *result, const char *storename, const uint8 *itemlist, unsigned int *count); + void (*postHookFunc) (struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_buyingstore_create_post[hIndex].func; - postHookFunc(sd, &zenylimit, &result, storename, itemlist, &count); + postHookFunc(sd, zenylimit, result, storename, itemlist, count); } } return; @@ -3476,11 +3501,11 @@ void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned void HP_buyingstore_close(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_buyingstore_close_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_close_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3502,11 +3527,11 @@ void HP_buyingstore_close(struct map_session_data *sd) { void HP_buyingstore_open(struct map_session_data *sd, int account_id) { int hIndex = 0; if( HPMHooks.count.HP_buyingstore_open_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id); + void (*preHookFunc) (struct map_session_data **sd, int *account_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_open_pre[hIndex].func; - preHookFunc(sd, &account_id); + preHookFunc(&sd, &account_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3517,10 +3542,10 @@ void HP_buyingstore_open(struct map_session_data *sd, int account_id) { HPMHooks.source.buyingstore.open(sd, account_id); } if( HPMHooks.count.HP_buyingstore_open_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id); + void (*postHookFunc) (struct map_session_data *sd, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_buyingstore_open_post[hIndex].func; - postHookFunc(sd, &account_id); + postHookFunc(sd, account_id); } } return; @@ -3528,11 +3553,11 @@ void HP_buyingstore_open(struct map_session_data *sd, int account_id) { void HP_buyingstore_trade(struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count) { int hIndex = 0; if( HPMHooks.count.HP_buyingstore_trade_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, unsigned int *buyer_id, const uint8 *itemlist, unsigned int *count); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, unsigned int *buyer_id, const uint8 **itemlist, unsigned int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_trade_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_trade_pre[hIndex].func; - preHookFunc(sd, &account_id, &buyer_id, itemlist, &count); + preHookFunc(&sd, &account_id, &buyer_id, &itemlist, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3543,10 +3568,10 @@ void HP_buyingstore_trade(struct map_session_data *sd, int account_id, unsigned HPMHooks.source.buyingstore.trade(sd, account_id, buyer_id, itemlist, count); } if( HPMHooks.count.HP_buyingstore_trade_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, unsigned int *buyer_id, const uint8 *itemlist, unsigned int *count); + void (*postHookFunc) (struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_trade_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_buyingstore_trade_post[hIndex].func; - postHookFunc(sd, &account_id, &buyer_id, itemlist, &count); + postHookFunc(sd, account_id, buyer_id, itemlist, count); } } return; @@ -3555,11 +3580,11 @@ bool HP_buyingstore_search(struct map_session_data *sd, unsigned short nameid) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_buyingstore_search_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid); + bool (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_search_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3570,10 +3595,10 @@ bool HP_buyingstore_search(struct map_session_data *sd, unsigned short nameid) { retVal___ = HPMHooks.source.buyingstore.search(sd, nameid); } if( HPMHooks.count.HP_buyingstore_search_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short *nameid); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_buyingstore_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -3582,11 +3607,11 @@ bool HP_buyingstore_searchall(struct map_session_data *sd, const struct s_search int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_buyingstore_searchall_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s); + bool (*preHookFunc) (struct map_session_data **sd, const struct s_search_store_search **s); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_searchall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_buyingstore_searchall_pre[hIndex].func; - retVal___ = preHookFunc(sd, s); + retVal___ = preHookFunc(&sd, &s); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3652,10 +3677,10 @@ int HP_channel_init(bool minimal) { retVal___ = HPMHooks.source.channel.init(minimal); } if( HPMHooks.count.HP_channel_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + int (*postHookFunc) (int retVal___, bool minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_channel_init_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -3690,11 +3715,11 @@ struct channel_data* HP_channel_search(const char *name, struct map_session_data int hIndex = 0; struct channel_data* retVal___ = NULL; if( HPMHooks.count.HP_channel_search_pre ) { - struct channel_data* (*preHookFunc) (const char *name, struct map_session_data *sd); + struct channel_data* (*preHookFunc) (const char **name, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_search_pre[hIndex].func; - retVal___ = preHookFunc(name, sd); + retVal___ = preHookFunc(&name, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3717,11 +3742,11 @@ struct channel_data* HP_channel_create(enum channel_types type, const char *name int hIndex = 0; struct channel_data* retVal___ = NULL; if( HPMHooks.count.HP_channel_create_pre ) { - struct channel_data* (*preHookFunc) (enum channel_types *type, const char *name, unsigned char *color); + struct channel_data* (*preHookFunc) (enum channel_types *type, const char **name, unsigned char *color); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_create_pre[hIndex].func; - retVal___ = preHookFunc(&type, name, &color); + retVal___ = preHookFunc(&type, &name, &color); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3732,10 +3757,10 @@ struct channel_data* HP_channel_create(enum channel_types type, const char *name retVal___ = HPMHooks.source.channel.create(type, name, color); } if( HPMHooks.count.HP_channel_create_post ) { - struct channel_data* (*postHookFunc) (struct channel_data* retVal___, enum channel_types *type, const char *name, unsigned char *color); + struct channel_data* (*postHookFunc) (struct channel_data* retVal___, enum channel_types type, const char *name, unsigned char color); for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_channel_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, name, &color); + retVal___ = postHookFunc(retVal___, type, name, color); } } return retVal___; @@ -3743,11 +3768,11 @@ struct channel_data* HP_channel_create(enum channel_types type, const char *name void HP_channel_delete(struct channel_data *chan) { int hIndex = 0; if( HPMHooks.count.HP_channel_delete_pre ) { - void (*preHookFunc) (struct channel_data *chan); + void (*preHookFunc) (struct channel_data **chan); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_delete_pre[hIndex].func; - preHookFunc(chan); + preHookFunc(&chan); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3769,11 +3794,11 @@ void HP_channel_delete(struct channel_data *chan) { void HP_channel_set_password(struct channel_data *chan, const char *password) { int hIndex = 0; if( HPMHooks.count.HP_channel_set_password_pre ) { - void (*preHookFunc) (struct channel_data *chan, const char *password); + void (*preHookFunc) (struct channel_data **chan, const char **password); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_password_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_set_password_pre[hIndex].func; - preHookFunc(chan, password); + preHookFunc(&chan, &password); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3796,11 +3821,11 @@ enum channel_operation_status HP_channel_ban(struct channel_data *chan, const st int hIndex = 0; enum channel_operation_status retVal___ = HCS_STATUS_FAIL; if( HPMHooks.count.HP_channel_ban_pre ) { - enum channel_operation_status (*preHookFunc) (struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd); + enum channel_operation_status (*preHookFunc) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_ban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_ban_pre[hIndex].func; - retVal___ = preHookFunc(chan, ssd, tsd); + retVal___ = preHookFunc(&chan, &ssd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3823,11 +3848,11 @@ enum channel_operation_status HP_channel_unban(struct channel_data *chan, const int hIndex = 0; enum channel_operation_status retVal___ = HCS_STATUS_FAIL; if( HPMHooks.count.HP_channel_unban_pre ) { - enum channel_operation_status (*preHookFunc) (struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd); + enum channel_operation_status (*preHookFunc) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_unban_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_unban_pre[hIndex].func; - retVal___ = preHookFunc(chan, ssd, tsd); + retVal___ = preHookFunc(&chan, &ssd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3849,11 +3874,11 @@ enum channel_operation_status HP_channel_unban(struct channel_data *chan, const void HP_channel_set_options(struct channel_data *chan, unsigned int options) { int hIndex = 0; if( HPMHooks.count.HP_channel_set_options_pre ) { - void (*preHookFunc) (struct channel_data *chan, unsigned int *options); + void (*preHookFunc) (struct channel_data **chan, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_set_options_pre[hIndex].func; - preHookFunc(chan, &options); + preHookFunc(&chan, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3864,10 +3889,10 @@ void HP_channel_set_options(struct channel_data *chan, unsigned int options) { HPMHooks.source.channel.set_options(chan, options); } if( HPMHooks.count.HP_channel_set_options_post ) { - void (*postHookFunc) (struct channel_data *chan, unsigned int *options); + void (*postHookFunc) (struct channel_data *chan, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_channel_set_options_post[hIndex].func; - postHookFunc(chan, &options); + postHookFunc(chan, options); } } return; @@ -3875,11 +3900,11 @@ void HP_channel_set_options(struct channel_data *chan, unsigned int options) { void HP_channel_send(struct channel_data *chan, struct map_session_data *sd, const char *msg) { int hIndex = 0; if( HPMHooks.count.HP_channel_send_pre ) { - void (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd, const char *msg); + void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, const char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_send_pre[hIndex].func; - preHookFunc(chan, sd, msg); + preHookFunc(&chan, &sd, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3901,11 +3926,11 @@ void HP_channel_send(struct channel_data *chan, struct map_session_data *sd, con void HP_channel_join_sub(struct channel_data *chan, struct map_session_data *sd, bool stealth) { int hIndex = 0; if( HPMHooks.count.HP_channel_join_sub_pre ) { - void (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd, bool *stealth); + void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, bool *stealth); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_join_sub_pre[hIndex].func; - preHookFunc(chan, sd, &stealth); + preHookFunc(&chan, &sd, &stealth); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3916,10 +3941,10 @@ void HP_channel_join_sub(struct channel_data *chan, struct map_session_data *sd, HPMHooks.source.channel.join_sub(chan, sd, stealth); } if( HPMHooks.count.HP_channel_join_sub_post ) { - void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd, bool *stealth); + void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd, bool stealth); for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_channel_join_sub_post[hIndex].func; - postHookFunc(chan, sd, &stealth); + postHookFunc(chan, sd, stealth); } } return; @@ -3928,11 +3953,11 @@ enum channel_operation_status HP_channel_join(struct channel_data *chan, struct int hIndex = 0; enum channel_operation_status retVal___ = HCS_STATUS_FAIL; if( HPMHooks.count.HP_channel_join_pre ) { - enum channel_operation_status (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd, const char *password, bool *silent); + enum channel_operation_status (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, const char **password, bool *silent); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_join_pre[hIndex].func; - retVal___ = preHookFunc(chan, sd, password, &silent); + retVal___ = preHookFunc(&chan, &sd, &password, &silent); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3943,10 +3968,10 @@ enum channel_operation_status HP_channel_join(struct channel_data *chan, struct retVal___ = HPMHooks.source.channel.join(chan, sd, password, silent); } if( HPMHooks.count.HP_channel_join_post ) { - enum channel_operation_status (*postHookFunc) (enum channel_operation_status retVal___, struct channel_data *chan, struct map_session_data *sd, const char *password, bool *silent); + enum channel_operation_status (*postHookFunc) (enum channel_operation_status retVal___, struct channel_data *chan, struct map_session_data *sd, const char *password, bool silent); for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_channel_join_post[hIndex].func; - retVal___ = postHookFunc(retVal___, chan, sd, password, &silent); + retVal___ = postHookFunc(retVal___, chan, sd, password, silent); } } return retVal___; @@ -3954,11 +3979,11 @@ enum channel_operation_status HP_channel_join(struct channel_data *chan, struct void HP_channel_leave(struct channel_data *chan, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_leave_pre ) { - void (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd); + void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_leave_pre[hIndex].func; - preHookFunc(chan, sd); + preHookFunc(&chan, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -3980,11 +4005,11 @@ void HP_channel_leave(struct channel_data *chan, struct map_session_data *sd) { void HP_channel_leave_sub(struct channel_data *chan, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_leave_sub_pre ) { - void (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd); + void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_leave_sub_pre[hIndex].func; - preHookFunc(chan, sd); + preHookFunc(&chan, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4006,11 +4031,11 @@ void HP_channel_leave_sub(struct channel_data *chan, struct map_session_data *sd void HP_channel_quit(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_quit_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_quit_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4032,11 +4057,11 @@ void HP_channel_quit(struct map_session_data *sd) { void HP_channel_map_join(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_map_join_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_map_join_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_map_join_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4058,11 +4083,11 @@ void HP_channel_map_join(struct map_session_data *sd) { void HP_channel_guild_join_alliance(const struct guild *g_source, const struct guild *g_ally) { int hIndex = 0; if( HPMHooks.count.HP_channel_guild_join_alliance_pre ) { - void (*preHookFunc) (const struct guild *g_source, const struct guild *g_ally); + void (*preHookFunc) (const struct guild **g_source, const struct guild **g_ally); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_join_alliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_guild_join_alliance_pre[hIndex].func; - preHookFunc(g_source, g_ally); + preHookFunc(&g_source, &g_ally); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4084,11 +4109,11 @@ void HP_channel_guild_join_alliance(const struct guild *g_source, const struct g void HP_channel_guild_leave_alliance(const struct guild *g_source, const struct guild *g_ally) { int hIndex = 0; if( HPMHooks.count.HP_channel_guild_leave_alliance_pre ) { - void (*preHookFunc) (const struct guild *g_source, const struct guild *g_ally); + void (*preHookFunc) (const struct guild **g_source, const struct guild **g_ally); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_leave_alliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_guild_leave_alliance_pre[hIndex].func; - preHookFunc(g_source, g_ally); + preHookFunc(&g_source, &g_ally); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4110,11 +4135,11 @@ void HP_channel_guild_leave_alliance(const struct guild *g_source, const struct void HP_channel_quit_guild(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_quit_guild_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_guild_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_quit_guild_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4136,11 +4161,11 @@ void HP_channel_quit_guild(struct map_session_data *sd) { void HP_channel_irc_join(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_channel_irc_join_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_irc_join_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_channel_irc_join_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4190,11 +4215,11 @@ bool HP_chat_create_pc_chat(struct map_session_data *sd, const char *title, cons int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_create_pc_chat_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub); + bool (*preHookFunc) (struct map_session_data **sd, const char **title, const char **pass, int *limit, bool *pub); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pc_chat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_create_pc_chat_pre[hIndex].func; - retVal___ = preHookFunc(sd, title, pass, &limit, &pub); + retVal___ = preHookFunc(&sd, &title, &pass, &limit, &pub); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4205,10 +4230,10 @@ bool HP_chat_create_pc_chat(struct map_session_data *sd, const char *title, cons retVal___ = HPMHooks.source.chat.create_pc_chat(sd, title, pass, limit, pub); } if( HPMHooks.count.HP_chat_create_pc_chat_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pc_chat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_create_pc_chat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, title, pass, &limit, &pub); + retVal___ = postHookFunc(retVal___, sd, title, pass, limit, pub); } } return retVal___; @@ -4217,11 +4242,11 @@ bool HP_chat_join(struct map_session_data *sd, int chatid, const char *pass) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_join_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *chatid, const char *pass); + bool (*preHookFunc) (struct map_session_data **sd, int *chatid, const char **pass); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_join_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_join_pre[hIndex].func; - retVal___ = preHookFunc(sd, &chatid, pass); + retVal___ = preHookFunc(&sd, &chatid, &pass); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4232,10 +4257,10 @@ bool HP_chat_join(struct map_session_data *sd, int chatid, const char *pass) { retVal___ = HPMHooks.source.chat.join(sd, chatid, pass); } if( HPMHooks.count.HP_chat_join_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *chatid, const char *pass); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int chatid, const char *pass); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_join_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_join_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &chatid, pass); + retVal___ = postHookFunc(retVal___, sd, chatid, pass); } } return retVal___; @@ -4244,11 +4269,11 @@ int HP_chat_leave(struct map_session_data *sd, bool kicked) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chat_leave_pre ) { - int (*preHookFunc) (struct map_session_data *sd, bool *kicked); + int (*preHookFunc) (struct map_session_data **sd, bool *kicked); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_leave_pre[hIndex].func; - retVal___ = preHookFunc(sd, &kicked); + retVal___ = preHookFunc(&sd, &kicked); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4259,10 +4284,10 @@ int HP_chat_leave(struct map_session_data *sd, bool kicked) { retVal___ = HPMHooks.source.chat.leave(sd, kicked); } if( HPMHooks.count.HP_chat_leave_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *kicked); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool kicked); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &kicked); + retVal___ = postHookFunc(retVal___, sd, kicked); } } return retVal___; @@ -4271,11 +4296,11 @@ bool HP_chat_change_owner(struct map_session_data *sd, const char *nextownername int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_change_owner_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *nextownername); + bool (*preHookFunc) (struct map_session_data **sd, const char **nextownername); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_owner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_change_owner_pre[hIndex].func; - retVal___ = preHookFunc(sd, nextownername); + retVal___ = preHookFunc(&sd, &nextownername); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4298,11 +4323,11 @@ bool HP_chat_change_status(struct map_session_data *sd, const char *title, const int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_change_status_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub); + bool (*preHookFunc) (struct map_session_data **sd, const char **title, const char **pass, int *limit, bool *pub); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_change_status_pre[hIndex].func; - retVal___ = preHookFunc(sd, title, pass, &limit, &pub); + retVal___ = preHookFunc(&sd, &title, &pass, &limit, &pub); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4313,10 +4338,10 @@ bool HP_chat_change_status(struct map_session_data *sd, const char *title, const retVal___ = HPMHooks.source.chat.change_status(sd, title, pass, limit, pub); } if( HPMHooks.count.HP_chat_change_status_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_status_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_change_status_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, title, pass, &limit, &pub); + retVal___ = postHookFunc(retVal___, sd, title, pass, limit, pub); } } return retVal___; @@ -4325,11 +4350,11 @@ bool HP_chat_kick(struct map_session_data *sd, const char *kickusername) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_kick_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *kickusername); + bool (*preHookFunc) (struct map_session_data **sd, const char **kickusername); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_kick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_kick_pre[hIndex].func; - retVal___ = preHookFunc(sd, kickusername); + retVal___ = preHookFunc(&sd, &kickusername); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4352,11 +4377,11 @@ bool HP_chat_create_npc_chat(struct npc_data *nd, const char *title, int limit, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_create_npc_chat_pre ) { - bool (*preHookFunc) (struct npc_data *nd, const char *title, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl); + bool (*preHookFunc) (struct npc_data **nd, const char **title, int *limit, bool *pub, int *trigger, const char **ev, int *zeny, int *minLvl, int *maxLvl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_npc_chat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_create_npc_chat_pre[hIndex].func; - retVal___ = preHookFunc(nd, title, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl); + retVal___ = preHookFunc(&nd, &title, &limit, &pub, &trigger, &ev, &zeny, &minLvl, &maxLvl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4367,10 +4392,10 @@ bool HP_chat_create_npc_chat(struct npc_data *nd, const char *title, int limit, retVal___ = HPMHooks.source.chat.create_npc_chat(nd, title, limit, pub, trigger, ev, zeny, minLvl, maxLvl); } if( HPMHooks.count.HP_chat_create_npc_chat_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const char *title, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const char *title, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_npc_chat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_create_npc_chat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, title, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl); + retVal___ = postHookFunc(retVal___, nd, title, limit, pub, trigger, ev, zeny, minLvl, maxLvl); } } return retVal___; @@ -4379,11 +4404,11 @@ bool HP_chat_delete_npc_chat(struct npc_data *nd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_delete_npc_chat_pre ) { - bool (*preHookFunc) (struct npc_data *nd); + bool (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_delete_npc_chat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_delete_npc_chat_pre[hIndex].func; - retVal___ = preHookFunc(nd); + retVal___ = preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4406,11 +4431,11 @@ bool HP_chat_enable_event(struct chat_data *cd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_enable_event_pre ) { - bool (*preHookFunc) (struct chat_data *cd); + bool (*preHookFunc) (struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_enable_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_enable_event_pre[hIndex].func; - retVal___ = preHookFunc(cd); + retVal___ = preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4433,11 +4458,11 @@ bool HP_chat_disable_event(struct chat_data *cd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_disable_event_pre ) { - bool (*preHookFunc) (struct chat_data *cd); + bool (*preHookFunc) (struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_disable_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_disable_event_pre[hIndex].func; - retVal___ = preHookFunc(cd); + retVal___ = preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4460,11 +4485,11 @@ bool HP_chat_npc_kick_all(struct chat_data *cd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_npc_kick_all_pre ) { - bool (*preHookFunc) (struct chat_data *cd); + bool (*preHookFunc) (struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_npc_kick_all_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_npc_kick_all_pre[hIndex].func; - retVal___ = preHookFunc(cd); + retVal___ = preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4487,11 +4512,11 @@ bool HP_chat_trigger_event(struct chat_data *cd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chat_trigger_event_pre ) { - bool (*preHookFunc) (struct chat_data *cd); + bool (*preHookFunc) (struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_trigger_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_trigger_event_pre[hIndex].func; - retVal___ = preHookFunc(cd); + retVal___ = preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4514,11 +4539,11 @@ struct chat_data* HP_chat_create(struct block_list *bl, const char *title, const int hIndex = 0; struct chat_data* retVal___ = NULL; if( HPMHooks.count.HP_chat_create_pre ) { - struct chat_data* (*preHookFunc) (struct block_list *bl, const char *title, const char *pass, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl); + struct chat_data* (*preHookFunc) (struct block_list **bl, const char **title, const char **pass, int *limit, bool *pub, int *trigger, const char **ev, int *zeny, int *minLvl, int *maxLvl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chat_create_pre[hIndex].func; - retVal___ = preHookFunc(bl, title, pass, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl); + retVal___ = preHookFunc(&bl, &title, &pass, &limit, &pub, &trigger, &ev, &zeny, &minLvl, &maxLvl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4529,10 +4554,10 @@ struct chat_data* HP_chat_create(struct block_list *bl, const char *title, const retVal___ = HPMHooks.source.chat.create(bl, title, pass, limit, pub, trigger, ev, zeny, minLvl, maxLvl); } if( HPMHooks.count.HP_chat_create_post ) { - struct chat_data* (*postHookFunc) (struct chat_data* retVal___, struct block_list *bl, const char *title, const char *pass, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl); + struct chat_data* (*postHookFunc) (struct chat_data* retVal___, struct block_list *bl, const char *title, const char *pass, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl); for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chat_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, title, pass, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl); + retVal___ = postHookFunc(retVal___, bl, title, pass, limit, pub, trigger, ev, zeny, minLvl, maxLvl); } } return retVal___; @@ -4556,10 +4581,10 @@ void HP_chrif_init(bool minimal) { HPMHooks.source.chrif.init(minimal); } if( HPMHooks.count.HP_chrif_init_post ) { - void (*postHookFunc) (bool *minimal); + void (*postHookFunc) (bool minimal); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_init_post[hIndex].func; - postHookFunc(&minimal); + postHookFunc(minimal); } } return; @@ -4593,11 +4618,11 @@ void HP_chrif_final(void) { void HP_chrif_setuserid(char *id) { int hIndex = 0; if( HPMHooks.count.HP_chrif_setuserid_pre ) { - void (*preHookFunc) (char *id); + void (*preHookFunc) (char **id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setuserid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_setuserid_pre[hIndex].func; - preHookFunc(id); + preHookFunc(&id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4619,11 +4644,11 @@ void HP_chrif_setuserid(char *id) { void HP_chrif_setpasswd(char *pwd) { int hIndex = 0; if( HPMHooks.count.HP_chrif_setpasswd_pre ) { - void (*preHookFunc) (char *pwd); + void (*preHookFunc) (char **pwd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setpasswd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_setpasswd_pre[hIndex].func; - preHookFunc(pwd); + preHookFunc(&pwd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4672,11 +4697,11 @@ bool HP_chrif_setip(const char *ip) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_setip_pre ) { - bool (*preHookFunc) (const char *ip); + bool (*preHookFunc) (const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_setip_pre[hIndex].func; - retVal___ = preHookFunc(ip); + retVal___ = preHookFunc(&ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4713,10 +4738,10 @@ void HP_chrif_setport(uint16 port) { HPMHooks.source.chrif.setport(port); } if( HPMHooks.count.HP_chrif_setport_post ) { - void (*postHookFunc) (uint16 *port); + void (*postHookFunc) (uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_setport_post[hIndex].func; - postHookFunc(&port); + postHookFunc(port); } } return; @@ -4793,10 +4818,10 @@ struct auth_node* HP_chrif_search(int account_id) { retVal___ = HPMHooks.source.chrif.search(account_id); } if( HPMHooks.count.HP_chrif_search_post ) { - struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int *account_id); + struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id); + retVal___ = postHookFunc(retVal___, account_id); } } return retVal___; @@ -4820,10 +4845,10 @@ struct auth_node* HP_chrif_auth_check(int account_id, int char_id, enum sd_state retVal___ = HPMHooks.source.chrif.auth_check(account_id, char_id, state); } if( HPMHooks.count.HP_chrif_auth_check_post ) { - struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int *account_id, int *char_id, enum sd_state *state); + struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int account_id, int char_id, enum sd_state state); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_auth_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id, &state); + retVal___ = postHookFunc(retVal___, account_id, char_id, state); } } return retVal___; @@ -4847,10 +4872,10 @@ bool HP_chrif_auth_delete(int account_id, int char_id, enum sd_state state) { retVal___ = HPMHooks.source.chrif.auth_delete(account_id, char_id, state); } if( HPMHooks.count.HP_chrif_auth_delete_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, int *char_id, enum sd_state *state); + bool (*postHookFunc) (bool retVal___, int account_id, int char_id, enum sd_state state); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_auth_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id, &state); + retVal___ = postHookFunc(retVal___, account_id, char_id, state); } } return retVal___; @@ -4859,11 +4884,11 @@ bool HP_chrif_auth_finished(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_auth_finished_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_finished_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_auth_finished_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4885,11 +4910,11 @@ bool HP_chrif_auth_finished(struct map_session_data *sd) { void HP_chrif_authreq(struct map_session_data *sd, bool hstandalone) { int hIndex = 0; if( HPMHooks.count.HP_chrif_authreq_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *hstandalone); + void (*preHookFunc) (struct map_session_data **sd, bool *hstandalone); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_authreq_pre[hIndex].func; - preHookFunc(sd, &hstandalone); + preHookFunc(&sd, &hstandalone); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4900,10 +4925,10 @@ void HP_chrif_authreq(struct map_session_data *sd, bool hstandalone) { HPMHooks.source.chrif.authreq(sd, hstandalone); } if( HPMHooks.count.HP_chrif_authreq_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *hstandalone); + void (*postHookFunc) (struct map_session_data *sd, bool hstandalone); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_authreq_post[hIndex].func; - postHookFunc(sd, &hstandalone); + postHookFunc(sd, hstandalone); } } return; @@ -4926,10 +4951,10 @@ void HP_chrif_authok(int fd) { HPMHooks.source.chrif.authok(fd); } if( HPMHooks.count.HP_chrif_authok_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_authok_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -4953,10 +4978,10 @@ bool HP_chrif_scdata_request(int account_id, int char_id) { retVal___ = HPMHooks.source.chrif.scdata_request(account_id, char_id); } if( HPMHooks.count.HP_chrif_scdata_request_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, int *char_id); + bool (*postHookFunc) (bool retVal___, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_scdata_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_scdata_request_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, account_id, char_id); } } return retVal___; @@ -4965,11 +4990,11 @@ bool HP_chrif_save(struct map_session_data *sd, int flag) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_save_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *flag); + bool (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_save_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -4980,10 +5005,10 @@ bool HP_chrif_save(struct map_session_data *sd, int flag) { retVal___ = HPMHooks.source.chrif.save(sd, flag); } if( HPMHooks.count.HP_chrif_save_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *flag); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_save_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -4992,11 +5017,11 @@ bool HP_chrif_charselectreq(struct map_session_data *sd, uint32 s_ip) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_charselectreq_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, uint32 *s_ip); + bool (*preHookFunc) (struct map_session_data **sd, uint32 *s_ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_charselectreq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_charselectreq_pre[hIndex].func; - retVal___ = preHookFunc(sd, &s_ip); + retVal___ = preHookFunc(&sd, &s_ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5007,10 +5032,10 @@ bool HP_chrif_charselectreq(struct map_session_data *sd, uint32 s_ip) { retVal___ = HPMHooks.source.chrif.charselectreq(sd, s_ip); } if( HPMHooks.count.HP_chrif_charselectreq_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 *s_ip); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 s_ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_charselectreq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_charselectreq_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &s_ip); + retVal___ = postHookFunc(retVal___, sd, s_ip); } } return retVal___; @@ -5019,11 +5044,11 @@ bool HP_chrif_changemapserver(struct map_session_data *sd, uint32 ip, uint16 por int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_changemapserver_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, uint32 *ip, uint16 *port); + bool (*preHookFunc) (struct map_session_data **sd, uint32 *ip, uint16 *port); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserver_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_changemapserver_pre[hIndex].func; - retVal___ = preHookFunc(sd, &ip, &port); + retVal___ = preHookFunc(&sd, &ip, &port); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5034,10 +5059,10 @@ bool HP_chrif_changemapserver(struct map_session_data *sd, uint32 ip, uint16 por retVal___ = HPMHooks.source.chrif.changemapserver(sd, ip, port); } if( HPMHooks.count.HP_chrif_changemapserver_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 *ip, uint16 *port); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserver_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_changemapserver_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &ip, &port); + retVal___ = postHookFunc(retVal___, sd, ip, port); } } return retVal___; @@ -5061,10 +5086,10 @@ bool HP_chrif_searchcharid(int char_id) { retVal___ = HPMHooks.source.chrif.searchcharid(char_id); } if( HPMHooks.count.HP_chrif_searchcharid_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id); + bool (*postHookFunc) (bool retVal___, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_searchcharid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_searchcharid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id); + retVal___ = postHookFunc(retVal___, char_id); } } return retVal___; @@ -5073,11 +5098,11 @@ bool HP_chrif_changeemail(int id, const char *actual_email, const char *new_emai int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_changeemail_pre ) { - bool (*preHookFunc) (int *id, const char *actual_email, const char *new_email); + bool (*preHookFunc) (int *id, const char **actual_email, const char **new_email); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changeemail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_changeemail_pre[hIndex].func; - retVal___ = preHookFunc(&id, actual_email, new_email); + retVal___ = preHookFunc(&id, &actual_email, &new_email); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5088,10 +5113,10 @@ bool HP_chrif_changeemail(int id, const char *actual_email, const char *new_emai retVal___ = HPMHooks.source.chrif.changeemail(id, actual_email, new_email); } if( HPMHooks.count.HP_chrif_changeemail_post ) { - bool (*postHookFunc) (bool retVal___, int *id, const char *actual_email, const char *new_email); + bool (*postHookFunc) (bool retVal___, int id, const char *actual_email, const char *new_email); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changeemail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_changeemail_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id, actual_email, new_email); + retVal___ = postHookFunc(retVal___, id, actual_email, new_email); } } return retVal___; @@ -5100,11 +5125,11 @@ bool HP_chrif_char_ask_name(int acc, const char *character_name, unsigned short int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_char_ask_name_pre ) { - bool (*preHookFunc) (int *acc, const char *character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second); + bool (*preHookFunc) (int *acc, const char **character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_char_ask_name_pre[hIndex].func; - retVal___ = preHookFunc(&acc, character_name, &operation_type, &year, &month, &day, &hour, &minute, &second); + retVal___ = preHookFunc(&acc, &character_name, &operation_type, &year, &month, &day, &hour, &minute, &second); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5115,10 +5140,10 @@ bool HP_chrif_char_ask_name(int acc, const char *character_name, unsigned short retVal___ = HPMHooks.source.chrif.char_ask_name(acc, character_name, operation_type, year, month, day, hour, minute, second); } if( HPMHooks.count.HP_chrif_char_ask_name_post ) { - bool (*postHookFunc) (bool retVal___, int *acc, const char *character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second); + bool (*postHookFunc) (bool retVal___, int acc, const char *character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &acc, character_name, &operation_type, &year, &month, &day, &hour, &minute, &second); + retVal___ = postHookFunc(retVal___, acc, character_name, operation_type, year, month, day, hour, minute, second); } } return retVal___; @@ -5127,11 +5152,11 @@ int HP_chrif_updatefamelist(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chrif_updatefamelist_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_updatefamelist_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5181,11 +5206,11 @@ bool HP_chrif_save_scdata(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_save_scdata_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_save_scdata_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5223,10 +5248,10 @@ bool HP_chrif_ragsrvinfo(int base_rate, int job_rate, int drop_rate) { retVal___ = HPMHooks.source.chrif.ragsrvinfo(base_rate, job_rate, drop_rate); } if( HPMHooks.count.HP_chrif_ragsrvinfo_post ) { - bool (*postHookFunc) (bool retVal___, int *base_rate, int *job_rate, int *drop_rate); + bool (*postHookFunc) (bool retVal___, int base_rate, int job_rate, int drop_rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_ragsrvinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_ragsrvinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &base_rate, &job_rate, &drop_rate); + retVal___ = postHookFunc(retVal___, base_rate, job_rate, drop_rate); } } return retVal___; @@ -5250,10 +5275,10 @@ bool HP_chrif_char_offline_nsd(int account_id, int char_id) { retVal___ = HPMHooks.source.chrif.char_offline_nsd(account_id, char_id); } if( HPMHooks.count.HP_chrif_char_offline_nsd_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, int *char_id); + bool (*postHookFunc) (bool retVal___, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_nsd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_char_offline_nsd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, account_id, char_id); } } return retVal___; @@ -5316,11 +5341,11 @@ bool HP_chrif_char_online(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_char_online_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_online_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_char_online_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5343,11 +5368,11 @@ bool HP_chrif_changesex(struct map_session_data *sd, bool change_account) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_changesex_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, bool *change_account); + bool (*preHookFunc) (struct map_session_data **sd, bool *change_account); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_changesex_pre[hIndex].func; - retVal___ = preHookFunc(sd, &change_account); + retVal___ = preHookFunc(&sd, &change_account); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5358,10 +5383,10 @@ bool HP_chrif_changesex(struct map_session_data *sd, bool change_account) { retVal___ = HPMHooks.source.chrif.changesex(sd, change_account); } if( HPMHooks.count.HP_chrif_changesex_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, bool *change_account); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, bool change_account); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_changesex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &change_account); + retVal___ = postHookFunc(retVal___, sd, change_account); } } return retVal___; @@ -5385,10 +5410,10 @@ bool HP_chrif_divorce(int partner_id1, int partner_id2) { retVal___ = HPMHooks.source.chrif.divorce(partner_id1, partner_id2); } if( HPMHooks.count.HP_chrif_divorce_post ) { - bool (*postHookFunc) (bool retVal___, int *partner_id1, int *partner_id2); + bool (*postHookFunc) (bool retVal___, int partner_id1, int partner_id2); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorce_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_divorce_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &partner_id1, &partner_id2); + retVal___ = postHookFunc(retVal___, partner_id1, partner_id2); } } return retVal___; @@ -5412,10 +5437,10 @@ bool HP_chrif_removefriend(int char_id, int friend_id) { retVal___ = HPMHooks.source.chrif.removefriend(char_id, friend_id); } if( HPMHooks.count.HP_chrif_removefriend_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, int *friend_id); + bool (*postHookFunc) (bool retVal___, int char_id, int friend_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removefriend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_removefriend_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &friend_id); + retVal___ = postHookFunc(retVal___, char_id, friend_id); } } return retVal___; @@ -5423,11 +5448,11 @@ bool HP_chrif_removefriend(int char_id, int friend_id) { void HP_chrif_send_report(char *buf, int len) { int hIndex = 0; if( HPMHooks.count.HP_chrif_send_report_pre ) { - void (*preHookFunc) (char *buf, int *len); + void (*preHookFunc) (char **buf, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_report_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_send_report_pre[hIndex].func; - preHookFunc(buf, &len); + preHookFunc(&buf, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5438,10 +5463,10 @@ void HP_chrif_send_report(char *buf, int len) { HPMHooks.source.chrif.send_report(buf, len); } if( HPMHooks.count.HP_chrif_send_report_post ) { - void (*postHookFunc) (char *buf, int *len); + void (*postHookFunc) (char *buf, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_report_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_send_report_post[hIndex].func; - postHookFunc(buf, &len); + postHookFunc(buf, len); } } return; @@ -5491,10 +5516,10 @@ void HP_chrif_skillid2idx(int fd) { HPMHooks.source.chrif.skillid2idx(fd); } if( HPMHooks.count.HP_chrif_skillid2idx_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_skillid2idx_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_skillid2idx_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5503,11 +5528,11 @@ bool HP_chrif_sd_to_auth(struct map_session_data *sd, enum sd_state state) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_sd_to_auth_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, enum sd_state *state); + bool (*preHookFunc) (struct map_session_data **sd, enum sd_state *state); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sd_to_auth_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_sd_to_auth_pre[hIndex].func; - retVal___ = preHookFunc(sd, &state); + retVal___ = preHookFunc(&sd, &state); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5518,10 +5543,10 @@ bool HP_chrif_sd_to_auth(struct map_session_data *sd, enum sd_state state) { retVal___ = HPMHooks.source.chrif.sd_to_auth(sd, state); } if( HPMHooks.count.HP_chrif_sd_to_auth_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state *state); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state state); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sd_to_auth_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_sd_to_auth_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &state); + retVal___ = postHookFunc(retVal___, sd, state); } } return retVal___; @@ -5545,10 +5570,10 @@ int HP_chrif_check_connect_char_server(int tid, int64 tick, int id, intptr_t dat retVal___ = HPMHooks.source.chrif.check_connect_char_server(tid, tick, id, data); } if( HPMHooks.count.HP_chrif_check_connect_char_server_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_connect_char_server_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_check_connect_char_server_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -5557,11 +5582,11 @@ bool HP_chrif_auth_logout(struct map_session_data *sd, enum sd_state state) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_auth_logout_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, enum sd_state *state); + bool (*preHookFunc) (struct map_session_data **sd, enum sd_state *state); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_logout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_auth_logout_pre[hIndex].func; - retVal___ = preHookFunc(sd, &state); + retVal___ = preHookFunc(&sd, &state); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5572,10 +5597,10 @@ bool HP_chrif_auth_logout(struct map_session_data *sd, enum sd_state state) { retVal___ = HPMHooks.source.chrif.auth_logout(sd, state); } if( HPMHooks.count.HP_chrif_auth_logout_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state *state); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state state); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_logout_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_auth_logout_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &state); + retVal___ = postHookFunc(retVal___, sd, state); } } return retVal___; @@ -5598,10 +5623,10 @@ void HP_chrif_save_ack(int fd) { HPMHooks.source.chrif.save_ack(fd); } if( HPMHooks.count.HP_chrif_save_ack_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_save_ack_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5610,12 +5635,12 @@ int HP_chrif_reconnect(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chrif_reconnect_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_reconnect_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chrif_reconnect_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5629,11 +5654,11 @@ int HP_chrif_reconnect(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_chrif_reconnect_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_reconnect_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chrif_reconnect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -5643,12 +5668,12 @@ int HP_chrif_auth_db_cleanup_sub(union DBKey key, struct DBData *data, va_list a int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5662,11 +5687,11 @@ int HP_chrif_auth_db_cleanup_sub(union DBKey key, struct DBData *data, va_list a va_end(ap___copy); } if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -5676,11 +5701,11 @@ bool HP_chrif_char_ask_name_answer(int acc, const char *player_name, uint16 type int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_chrif_char_ask_name_answer_pre ) { - bool (*preHookFunc) (int *acc, const char *player_name, uint16 *type, uint16 *answer); + bool (*preHookFunc) (int *acc, const char **player_name, uint16 *type, uint16 *answer); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_answer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_char_ask_name_answer_pre[hIndex].func; - retVal___ = preHookFunc(&acc, player_name, &type, &answer); + retVal___ = preHookFunc(&acc, &player_name, &type, &answer); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -5691,10 +5716,10 @@ bool HP_chrif_char_ask_name_answer(int acc, const char *player_name, uint16 type retVal___ = HPMHooks.source.chrif.char_ask_name_answer(acc, player_name, type, answer); } if( HPMHooks.count.HP_chrif_char_ask_name_answer_post ) { - bool (*postHookFunc) (bool retVal___, int *acc, const char *player_name, uint16 *type, uint16 *answer); + bool (*postHookFunc) (bool retVal___, int acc, const char *player_name, uint16 type, uint16 answer); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_answer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_answer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &acc, player_name, &type, &answer); + retVal___ = postHookFunc(retVal___, acc, player_name, type, answer); } } return retVal___; @@ -5703,12 +5728,12 @@ int HP_chrif_auth_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_chrif_auth_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_chrif_auth_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -5722,11 +5747,11 @@ int HP_chrif_auth_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_chrif_auth_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_chrif_auth_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -5751,10 +5776,10 @@ int HP_chrif_send_usercount_tochar(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chrif.send_usercount_tochar(tid, tick, id, data); } if( HPMHooks.count.HP_chrif_send_usercount_tochar_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_usercount_tochar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_send_usercount_tochar_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -5778,10 +5803,10 @@ int HP_chrif_auth_db_cleanup(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.chrif.auth_db_cleanup(tid, tick, id, data); } if( HPMHooks.count.HP_chrif_auth_db_cleanup_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -5804,10 +5829,10 @@ void HP_chrif_connect(int fd) { HPMHooks.source.chrif.connect(fd); } if( HPMHooks.count.HP_chrif_connect_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_connect_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5830,10 +5855,10 @@ void HP_chrif_connectack(int fd) { HPMHooks.source.chrif.connectack(fd); } if( HPMHooks.count.HP_chrif_connectack_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connectack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_connectack_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5856,10 +5881,10 @@ void HP_chrif_sendmap(int fd) { HPMHooks.source.chrif.sendmap(fd); } if( HPMHooks.count.HP_chrif_sendmap_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_sendmap_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5882,10 +5907,10 @@ void HP_chrif_sendmapack(int fd) { HPMHooks.source.chrif.sendmapack(fd); } if( HPMHooks.count.HP_chrif_sendmapack_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmapack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_sendmapack_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5908,10 +5933,10 @@ void HP_chrif_recvmap(int fd) { HPMHooks.source.chrif.recvmap(fd); } if( HPMHooks.count.HP_chrif_recvmap_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvmap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_recvmap_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5935,10 +5960,10 @@ bool HP_chrif_changemapserverack(int account_id, int login_id1, int login_id2, i retVal___ = HPMHooks.source.chrif.changemapserverack(account_id, login_id1, login_id2, char_id, map_index, x, y, ip, port); } if( HPMHooks.count.HP_chrif_changemapserverack_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, int *login_id1, int *login_id2, int *char_id, short *map_index, short *x, short *y, uint32 *ip, uint16 *port); + bool (*postHookFunc) (bool retVal___, int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserverack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_changemapserverack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &login_id1, &login_id2, &char_id, &map_index, &x, &y, &ip, &port); + retVal___ = postHookFunc(retVal___, account_id, login_id1, login_id2, char_id, map_index, x, y, ip, port); } } return retVal___; @@ -5961,10 +5986,10 @@ void HP_chrif_changedsex(int fd) { HPMHooks.source.chrif.changedsex(fd); } if( HPMHooks.count.HP_chrif_changedsex_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changedsex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_changedsex_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -5988,10 +6013,10 @@ bool HP_chrif_divorceack(int char_id, int partner_id) { retVal___ = HPMHooks.source.chrif.divorceack(char_id, partner_id); } if( HPMHooks.count.HP_chrif_divorceack_post ) { - bool (*postHookFunc) (bool retVal___, int *char_id, int *partner_id); + bool (*postHookFunc) (bool retVal___, int char_id, int partner_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorceack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_divorceack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &partner_id); + retVal___ = postHookFunc(retVal___, char_id, partner_id); } } return retVal___; @@ -6014,10 +6039,10 @@ void HP_chrif_idbanned(int fd) { HPMHooks.source.chrif.idbanned(fd); } if( HPMHooks.count.HP_chrif_idbanned_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_idbanned_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_idbanned_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6040,10 +6065,10 @@ void HP_chrif_recvfamelist(int fd) { HPMHooks.source.chrif.recvfamelist(fd); } if( HPMHooks.count.HP_chrif_recvfamelist_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvfamelist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_recvfamelist_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6067,10 +6092,10 @@ bool HP_chrif_load_scdata(int fd) { retVal___ = HPMHooks.source.chrif.load_scdata(fd); } if( HPMHooks.count.HP_chrif_load_scdata_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_load_scdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_load_scdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6093,10 +6118,10 @@ void HP_chrif_update_ip(int fd) { HPMHooks.source.chrif.update_ip(fd); } if( HPMHooks.count.HP_chrif_update_ip_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_update_ip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_update_ip_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6120,10 +6145,10 @@ int HP_chrif_disconnectplayer(int fd) { retVal___ = HPMHooks.source.chrif.disconnectplayer(fd); } if( HPMHooks.count.HP_chrif_disconnectplayer_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_disconnectplayer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_disconnectplayer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6146,10 +6171,10 @@ void HP_chrif_removemap(int fd) { HPMHooks.source.chrif.removemap(fd); } if( HPMHooks.count.HP_chrif_removemap_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_removemap_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6173,10 +6198,10 @@ int HP_chrif_updatefamelist_ack(int fd) { retVal___ = HPMHooks.source.chrif.updatefamelist_ack(fd); } if( HPMHooks.count.HP_chrif_updatefamelist_ack_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_updatefamelist_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6199,10 +6224,10 @@ void HP_chrif_keepalive(int fd) { HPMHooks.source.chrif.keepalive(fd); } if( HPMHooks.count.HP_chrif_keepalive_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_keepalive_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6225,10 +6250,10 @@ void HP_chrif_keepalive_ack(int fd) { HPMHooks.source.chrif.keepalive_ack(fd); } if( HPMHooks.count.HP_chrif_keepalive_ack_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_keepalive_ack_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6251,10 +6276,10 @@ void HP_chrif_deadopt(int father_id, int mother_id, int child_id) { HPMHooks.source.chrif.deadopt(father_id, mother_id, child_id); } if( HPMHooks.count.HP_chrif_deadopt_post ) { - void (*postHookFunc) (int *father_id, int *mother_id, int *child_id); + void (*postHookFunc) (int father_id, int mother_id, int child_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_deadopt_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_deadopt_post[hIndex].func; - postHookFunc(&father_id, &mother_id, &child_id); + postHookFunc(father_id, mother_id, child_id); } } return; @@ -6277,10 +6302,10 @@ void HP_chrif_authfail(int fd) { HPMHooks.source.chrif.authfail(fd); } if( HPMHooks.count.HP_chrif_authfail_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authfail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_authfail_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -6356,10 +6381,10 @@ int HP_chrif_parse(int fd) { retVal___ = HPMHooks.source.chrif.parse(fd); } if( HPMHooks.count.HP_chrif_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6367,11 +6392,11 @@ int HP_chrif_parse(int fd) { void HP_chrif_save_scdata_single(int account_id, int char_id, short type, struct status_change_entry *sce) { int hIndex = 0; if( HPMHooks.count.HP_chrif_save_scdata_single_pre ) { - void (*preHookFunc) (int *account_id, int *char_id, short *type, struct status_change_entry *sce); + void (*preHookFunc) (int *account_id, int *char_id, short *type, struct status_change_entry **sce); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_chrif_save_scdata_single_pre[hIndex].func; - preHookFunc(&account_id, &char_id, &type, sce); + preHookFunc(&account_id, &char_id, &type, &sce); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6382,10 +6407,10 @@ void HP_chrif_save_scdata_single(int account_id, int char_id, short type, struct HPMHooks.source.chrif.save_scdata_single(account_id, char_id, type, sce); } if( HPMHooks.count.HP_chrif_save_scdata_single_post ) { - void (*postHookFunc) (int *account_id, int *char_id, short *type, struct status_change_entry *sce); + void (*postHookFunc) (int account_id, int char_id, short type, struct status_change_entry *sce); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_save_scdata_single_post[hIndex].func; - postHookFunc(&account_id, &char_id, &type, sce); + postHookFunc(account_id, char_id, type, sce); } } return; @@ -6408,10 +6433,10 @@ void HP_chrif_del_scdata_single(int account_id, int char_id, short type) { HPMHooks.source.chrif.del_scdata_single(account_id, char_id, type); } if( HPMHooks.count.HP_chrif_del_scdata_single_post ) { - void (*postHookFunc) (int *account_id, int *char_id, short *type); + void (*postHookFunc) (int account_id, int char_id, short type); for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_del_scdata_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_chrif_del_scdata_single_post[hIndex].func; - postHookFunc(&account_id, &char_id, &type); + postHookFunc(account_id, char_id, type); } } return; @@ -6436,10 +6461,10 @@ int HP_clif_init(bool minimal) { retVal___ = HPMHooks.source.clif.init(minimal); } if( HPMHooks.count.HP_clif_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -6474,11 +6499,11 @@ bool HP_clif_setip(const char *ip) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_clif_setip_pre ) { - bool (*preHookFunc) (const char *ip); + bool (*preHookFunc) (const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_setip_pre[hIndex].func; - retVal___ = preHookFunc(ip); + retVal___ = preHookFunc(&ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6501,11 +6526,11 @@ bool HP_clif_setbindip(const char *ip) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_clif_setbindip_pre ) { - bool (*preHookFunc) (const char *ip); + bool (*preHookFunc) (const char **ip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setbindip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_setbindip_pre[hIndex].func; - retVal___ = preHookFunc(ip); + retVal___ = preHookFunc(&ip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6542,10 +6567,10 @@ void HP_clif_setport(uint16 port) { HPMHooks.source.clif.setport(port); } if( HPMHooks.count.HP_clif_setport_post ) { - void (*postHookFunc) (uint16 *port); + void (*postHookFunc) (uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_setport_post[hIndex].func; - postHookFunc(&port); + postHookFunc(port); } } return; @@ -6581,11 +6606,11 @@ bool HP_clif_send(const void *buf, int len, struct block_list *bl, enum send_tar int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_clif_send_pre ) { - bool (*preHookFunc) (const void *buf, int *len, struct block_list *bl, enum send_target *type); + bool (*preHookFunc) (const void **buf, int *len, struct block_list **bl, enum send_target *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_send_pre[hIndex].func; - retVal___ = preHookFunc(buf, &len, bl, &type); + retVal___ = preHookFunc(&buf, &len, &bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6596,10 +6621,10 @@ bool HP_clif_send(const void *buf, int len, struct block_list *bl, enum send_tar retVal___ = HPMHooks.source.clif.send(buf, len, bl, type); } if( HPMHooks.count.HP_clif_send_post ) { - bool (*postHookFunc) (bool retVal___, const void *buf, int *len, struct block_list *bl, enum send_target *type); + bool (*postHookFunc) (bool retVal___, const void *buf, int len, struct block_list *bl, enum send_target type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_send_post[hIndex].func; - retVal___ = postHookFunc(retVal___, buf, &len, bl, &type); + retVal___ = postHookFunc(retVal___, buf, len, bl, type); } } return retVal___; @@ -6608,12 +6633,12 @@ int HP_clif_send_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_send_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_send_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -6641,11 +6666,11 @@ int HP_clif_send_actual(int fd, void *buf, int len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_send_actual_pre ) { - int (*preHookFunc) (int *fd, void *buf, int *len); + int (*preHookFunc) (int *fd, void **buf, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_actual_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_send_actual_pre[hIndex].func; - retVal___ = preHookFunc(&fd, buf, &len); + retVal___ = preHookFunc(&fd, &buf, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6656,10 +6681,10 @@ int HP_clif_send_actual(int fd, void *buf, int len) { retVal___ = HPMHooks.source.clif.send_actual(fd, buf, len); } if( HPMHooks.count.HP_clif_send_actual_post ) { - int (*postHookFunc) (int retVal___, int *fd, void *buf, int *len); + int (*postHookFunc) (int retVal___, int fd, void *buf, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_actual_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_send_actual_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, buf, &len); + retVal___ = postHookFunc(retVal___, fd, buf, len); } } return retVal___; @@ -6683,10 +6708,10 @@ int HP_clif_parse(int fd) { retVal___ = HPMHooks.source.clif.parse(fd); } if( HPMHooks.count.HP_clif_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -6710,10 +6735,10 @@ const struct s_packet_db* HP_clif_packet(int packet_id) { retVal___ = HPMHooks.source.clif.packet(packet_id); } if( HPMHooks.count.HP_clif_packet_post ) { - const struct s_packet_db* (*postHookFunc) (const struct s_packet_db* retVal___, int *packet_id); + const struct s_packet_db* (*postHookFunc) (const struct s_packet_db* retVal___, int packet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_packet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_packet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &packet_id); + retVal___ = postHookFunc(retVal___, packet_id); } } return retVal___; @@ -6722,11 +6747,11 @@ unsigned short HP_clif_parse_cmd(int fd, struct map_session_data *sd) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_clif_parse_cmd_pre ) { - unsigned short (*preHookFunc) (int *fd, struct map_session_data *sd); + unsigned short (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_cmd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_parse_cmd_pre[hIndex].func; - retVal___ = preHookFunc(&fd, sd); + retVal___ = preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6737,10 +6762,10 @@ unsigned short HP_clif_parse_cmd(int fd, struct map_session_data *sd) { retVal___ = HPMHooks.source.clif.parse_cmd(fd, sd); } if( HPMHooks.count.HP_clif_parse_cmd_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, int *fd, struct map_session_data *sd); + unsigned short (*postHookFunc) (unsigned short retVal___, int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_cmd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_parse_cmd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, sd); + retVal___ = postHookFunc(retVal___, fd, sd); } } return retVal___; @@ -6749,11 +6774,11 @@ unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_clif_decrypt_cmd_pre ) { - unsigned short (*preHookFunc) (int *cmd, struct map_session_data *sd); + unsigned short (*preHookFunc) (int *cmd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_decrypt_cmd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_decrypt_cmd_pre[hIndex].func; - retVal___ = preHookFunc(&cmd, sd); + retVal___ = preHookFunc(&cmd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6764,10 +6789,10 @@ unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) { retVal___ = HPMHooks.source.clif.decrypt_cmd(cmd, sd); } if( HPMHooks.count.HP_clif_decrypt_cmd_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, int *cmd, struct map_session_data *sd); + unsigned short (*postHookFunc) (unsigned short retVal___, int cmd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_decrypt_cmd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_decrypt_cmd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &cmd, sd); + retVal___ = postHookFunc(retVal___, cmd, sd); } } return retVal___; @@ -6775,11 +6800,11 @@ unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) { void HP_clif_authok(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_authok_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_authok_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6816,10 +6841,10 @@ void HP_clif_authrefuse(int fd, uint8 error_code) { HPMHooks.source.clif.authrefuse(fd, error_code); } if( HPMHooks.count.HP_clif_authrefuse_post ) { - void (*postHookFunc) (int *fd, uint8 *error_code); + void (*postHookFunc) (int fd, uint8 error_code); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authrefuse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_authrefuse_post[hIndex].func; - postHookFunc(&fd, &error_code); + postHookFunc(fd, error_code); } } return; @@ -6842,10 +6867,10 @@ void HP_clif_authfail_fd(int fd, int type) { HPMHooks.source.clif.authfail_fd(fd, type); } if( HPMHooks.count.HP_clif_authfail_fd_post ) { - void (*postHookFunc) (int *fd, int *type); + void (*postHookFunc) (int fd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authfail_fd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_authfail_fd_post[hIndex].func; - postHookFunc(&fd, &type); + postHookFunc(fd, type); } } return; @@ -6868,10 +6893,10 @@ void HP_clif_charselectok(int id, uint8 ok) { HPMHooks.source.clif.charselectok(id, ok); } if( HPMHooks.count.HP_clif_charselectok_post ) { - void (*postHookFunc) (int *id, uint8 *ok); + void (*postHookFunc) (int id, uint8 ok); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charselectok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_charselectok_post[hIndex].func; - postHookFunc(&id, &ok); + postHookFunc(id, ok); } } return; @@ -6879,11 +6904,11 @@ void HP_clif_charselectok(int id, uint8 ok) { void HP_clif_dropflooritem(struct flooritem_data *fitem) { int hIndex = 0; if( HPMHooks.count.HP_clif_dropflooritem_pre ) { - void (*preHookFunc) (struct flooritem_data *fitem); + void (*preHookFunc) (struct flooritem_data **fitem); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropflooritem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_dropflooritem_pre[hIndex].func; - preHookFunc(fitem); + preHookFunc(&fitem); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6905,11 +6930,11 @@ void HP_clif_dropflooritem(struct flooritem_data *fitem) { void HP_clif_clearflooritem(struct flooritem_data *fitem, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_clearflooritem_pre ) { - void (*preHookFunc) (struct flooritem_data *fitem, int *fd); + void (*preHookFunc) (struct flooritem_data **fitem, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_clearflooritem_pre[hIndex].func; - preHookFunc(fitem, &fd); + preHookFunc(&fitem, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6920,10 +6945,10 @@ void HP_clif_clearflooritem(struct flooritem_data *fitem, int fd) { HPMHooks.source.clif.clearflooritem(fitem, fd); } if( HPMHooks.count.HP_clif_clearflooritem_post ) { - void (*postHookFunc) (struct flooritem_data *fitem, int *fd); + void (*postHookFunc) (struct flooritem_data *fitem, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearflooritem_post[hIndex].func; - postHookFunc(fitem, &fd); + postHookFunc(fitem, fd); } } return; @@ -6931,11 +6956,11 @@ void HP_clif_clearflooritem(struct flooritem_data *fitem, int fd) { void HP_clif_additem(struct map_session_data *sd, int n, int amount, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_additem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_additem_pre[hIndex].func; - preHookFunc(sd, &n, &amount, &fail); + preHookFunc(&sd, &n, &amount, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6946,10 +6971,10 @@ void HP_clif_additem(struct map_session_data *sd, int n, int amount, int fail) { HPMHooks.source.clif.additem(sd, n, amount, fail); } if( HPMHooks.count.HP_clif_additem_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int n, int amount, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_additem_post[hIndex].func; - postHookFunc(sd, &n, &amount, &fail); + postHookFunc(sd, n, amount, fail); } } return; @@ -6957,11 +6982,11 @@ void HP_clif_additem(struct map_session_data *sd, int n, int amount, int fail) { void HP_clif_dropitem(struct map_session_data *sd, int n, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_dropitem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_dropitem_pre[hIndex].func; - preHookFunc(sd, &n, &amount); + preHookFunc(&sd, &n, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6972,10 +6997,10 @@ void HP_clif_dropitem(struct map_session_data *sd, int n, int amount) { HPMHooks.source.clif.dropitem(sd, n, amount); } if( HPMHooks.count.HP_clif_dropitem_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount); + void (*postHookFunc) (struct map_session_data *sd, int n, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_dropitem_post[hIndex].func; - postHookFunc(sd, &n, &amount); + postHookFunc(sd, n, amount); } } return; @@ -6983,11 +7008,11 @@ void HP_clif_dropitem(struct map_session_data *sd, int n, int amount) { void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reason) { int hIndex = 0; if( HPMHooks.count.HP_clif_delitem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, short *reason); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, short *reason); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_delitem_pre[hIndex].func; - preHookFunc(sd, &n, &amount, &reason); + preHookFunc(&sd, &n, &amount, &reason); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -6998,10 +7023,10 @@ void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reaso HPMHooks.source.clif.delitem(sd, n, amount, reason); } if( HPMHooks.count.HP_clif_delitem_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, short *reason); + void (*postHookFunc) (struct map_session_data *sd, int n, int amount, short reason); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_delitem_post[hIndex].func; - postHookFunc(sd, &n, &amount, &reason); + postHookFunc(sd, n, amount, reason); } } return; @@ -7009,11 +7034,11 @@ void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reaso void HP_clif_takeitem(struct block_list *src, struct block_list *dst) { int hIndex = 0; if( HPMHooks.count.HP_clif_takeitem_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *dst); + void (*preHookFunc) (struct block_list **src, struct block_list **dst); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_takeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_takeitem_pre[hIndex].func; - preHookFunc(src, dst); + preHookFunc(&src, &dst); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7035,11 +7060,11 @@ void HP_clif_takeitem(struct block_list *src, struct block_list *dst) { void HP_clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int eqp_pos) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_equip_pre ) { - void (*preHookFunc) (short *idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int *eqp_pos); + void (*preHookFunc) (short *idx, struct EQUIPITEM_INFO **p, struct item **i, struct item_data **id, int *eqp_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_equip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_equip_pre[hIndex].func; - preHookFunc(&idx, p, i, id, &eqp_pos); + preHookFunc(&idx, &p, &i, &id, &eqp_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7050,10 +7075,10 @@ void HP_clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, str HPMHooks.source.clif.item_equip(idx, p, i, id, eqp_pos); } if( HPMHooks.count.HP_clif_item_equip_post ) { - void (*postHookFunc) (short *idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int *eqp_pos); + void (*postHookFunc) (short idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int eqp_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_equip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_equip_post[hIndex].func; - postHookFunc(&idx, p, i, id, &eqp_pos); + postHookFunc(idx, p, i, id, eqp_pos); } } return; @@ -7061,11 +7086,11 @@ void HP_clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, str void HP_clif_item_normal(short idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_normal_pre ) { - void (*preHookFunc) (short *idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id); + void (*preHookFunc) (short *idx, struct NORMALITEM_INFO **p, struct item **i, struct item_data **id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_normal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_normal_pre[hIndex].func; - preHookFunc(&idx, p, i, id); + preHookFunc(&idx, &p, &i, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7076,10 +7101,10 @@ void HP_clif_item_normal(short idx, struct NORMALITEM_INFO *p, struct item *i, s HPMHooks.source.clif.item_normal(idx, p, i, id); } if( HPMHooks.count.HP_clif_item_normal_post ) { - void (*postHookFunc) (short *idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id); + void (*postHookFunc) (short idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_normal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_normal_post[hIndex].func; - postHookFunc(&idx, p, i, id); + postHookFunc(idx, p, i, id); } } return; @@ -7087,11 +7112,11 @@ void HP_clif_item_normal(short idx, struct NORMALITEM_INFO *p, struct item *i, s void HP_clif_arrowequip(struct map_session_data *sd, int val) { int hIndex = 0; if( HPMHooks.count.HP_clif_arrowequip_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *val); + void (*preHookFunc) (struct map_session_data **sd, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_arrowequip_pre[hIndex].func; - preHookFunc(sd, &val); + preHookFunc(&sd, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7102,10 +7127,10 @@ void HP_clif_arrowequip(struct map_session_data *sd, int val) { HPMHooks.source.clif.arrowequip(sd, val); } if( HPMHooks.count.HP_clif_arrowequip_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *val); + void (*postHookFunc) (struct map_session_data *sd, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_arrowequip_post[hIndex].func; - postHookFunc(sd, &val); + postHookFunc(sd, val); } } return; @@ -7113,11 +7138,11 @@ void HP_clif_arrowequip(struct map_session_data *sd, int val) { void HP_clif_arrow_fail(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_arrow_fail_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_fail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_arrow_fail_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7128,10 +7153,10 @@ void HP_clif_arrow_fail(struct map_session_data *sd, int type) { HPMHooks.source.clif.arrow_fail(sd, type); } if( HPMHooks.count.HP_clif_arrow_fail_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_fail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_arrow_fail_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -7139,11 +7164,11 @@ void HP_clif_arrow_fail(struct map_session_data *sd, int type) { void HP_clif_use_card(struct map_session_data *sd, int idx) { int hIndex = 0; if( HPMHooks.count.HP_clif_use_card_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx); + void (*preHookFunc) (struct map_session_data **sd, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_use_card_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_use_card_pre[hIndex].func; - preHookFunc(sd, &idx); + preHookFunc(&sd, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7154,10 +7179,10 @@ void HP_clif_use_card(struct map_session_data *sd, int idx) { HPMHooks.source.clif.use_card(sd, idx); } if( HPMHooks.count.HP_clif_use_card_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx); + void (*postHookFunc) (struct map_session_data *sd, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_use_card_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_use_card_post[hIndex].func; - postHookFunc(sd, &idx); + postHookFunc(sd, idx); } } return; @@ -7165,11 +7190,11 @@ void HP_clif_use_card(struct map_session_data *sd, int idx) { void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_cart_additem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cart_additem_pre[hIndex].func; - preHookFunc(sd, &n, &amount, &fail); + preHookFunc(&sd, &n, &amount, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7180,10 +7205,10 @@ void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fa HPMHooks.source.clif.cart_additem(sd, n, amount, fail); } if( HPMHooks.count.HP_clif_cart_additem_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int n, int amount, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cart_additem_post[hIndex].func; - postHookFunc(sd, &n, &amount, &fail); + postHookFunc(sd, n, amount, fail); } } return; @@ -7191,11 +7216,11 @@ void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fa void HP_clif_cart_delitem(struct map_session_data *sd, int n, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_cart_delitem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cart_delitem_pre[hIndex].func; - preHookFunc(sd, &n, &amount); + preHookFunc(&sd, &n, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7206,10 +7231,10 @@ void HP_clif_cart_delitem(struct map_session_data *sd, int n, int amount) { HPMHooks.source.clif.cart_delitem(sd, n, amount); } if( HPMHooks.count.HP_clif_cart_delitem_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount); + void (*postHookFunc) (struct map_session_data *sd, int n, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cart_delitem_post[hIndex].func; - postHookFunc(sd, &n, &amount); + postHookFunc(sd, n, amount); } } return; @@ -7217,11 +7242,11 @@ void HP_clif_cart_delitem(struct map_session_data *sd, int n, int amount) { void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, enum e_EQUIP_ITEM_ACK result) { int hIndex = 0; if( HPMHooks.count.HP_clif_equipitemack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_EQUIP_ITEM_ACK *result); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *pos, enum e_EQUIP_ITEM_ACK *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_equipitemack_pre[hIndex].func; - preHookFunc(sd, &n, &pos, &result); + preHookFunc(&sd, &n, &pos, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7232,10 +7257,10 @@ void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, enum e_EQ HPMHooks.source.clif.equipitemack(sd, n, pos, result); } if( HPMHooks.count.HP_clif_equipitemack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_EQUIP_ITEM_ACK *result); + void (*postHookFunc) (struct map_session_data *sd, int n, int pos, enum e_EQUIP_ITEM_ACK result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_equipitemack_post[hIndex].func; - postHookFunc(sd, &n, &pos, &result); + postHookFunc(sd, n, pos, result); } } return; @@ -7243,11 +7268,11 @@ void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, enum e_EQ void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, enum e_UNEQUIP_ITEM_ACK result) { int hIndex = 0; if( HPMHooks.count.HP_clif_unequipitemack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_UNEQUIP_ITEM_ACK *result); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *pos, enum e_UNEQUIP_ITEM_ACK *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_unequipitemack_pre[hIndex].func; - preHookFunc(sd, &n, &pos, &result); + preHookFunc(&sd, &n, &pos, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7258,10 +7283,10 @@ void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, enum e_ HPMHooks.source.clif.unequipitemack(sd, n, pos, result); } if( HPMHooks.count.HP_clif_unequipitemack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_UNEQUIP_ITEM_ACK *result); + void (*postHookFunc) (struct map_session_data *sd, int n, int pos, enum e_UNEQUIP_ITEM_ACK result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_unequipitemack_post[hIndex].func; - postHookFunc(sd, &n, &pos, &result); + postHookFunc(sd, n, pos, result); } } return; @@ -7269,11 +7294,11 @@ void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, enum e_ void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool ok) { int hIndex = 0; if( HPMHooks.count.HP_clif_useitemack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, bool *ok); + void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount, bool *ok); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useitemack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_useitemack_pre[hIndex].func; - preHookFunc(sd, &index, &amount, &ok); + preHookFunc(&sd, &index, &amount, &ok); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7284,10 +7309,10 @@ void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool HPMHooks.source.clif.useitemack(sd, index, amount, ok); } if( HPMHooks.count.HP_clif_useitemack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount, bool *ok); + void (*postHookFunc) (struct map_session_data *sd, int index, int amount, bool ok); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useitemack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_useitemack_post[hIndex].func; - postHookFunc(sd, &index, &amount, &ok); + postHookFunc(sd, index, amount, ok); } } return; @@ -7295,11 +7320,11 @@ void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool void HP_clif_addcards(unsigned char *buf, struct item *item) { int hIndex = 0; if( HPMHooks.count.HP_clif_addcards_pre ) { - void (*preHookFunc) (unsigned char *buf, struct item *item); + void (*preHookFunc) (unsigned char **buf, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_addcards_pre[hIndex].func; - preHookFunc(buf, item); + preHookFunc(&buf, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7321,11 +7346,11 @@ void HP_clif_addcards(unsigned char *buf, struct item *item) { void HP_clif_addcards2(unsigned short *cards, struct item *item) { int hIndex = 0; if( HPMHooks.count.HP_clif_addcards2_pre ) { - void (*preHookFunc) (unsigned short *cards, struct item *item); + void (*preHookFunc) (unsigned short **cards, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_addcards2_pre[hIndex].func; - preHookFunc(cards, item); + preHookFunc(&cards, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7347,11 +7372,11 @@ void HP_clif_addcards2(unsigned short *cards, struct item *item) { void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_data *id, int equip) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_sub_pre ) { - void (*preHookFunc) (unsigned char *buf, int *n, struct item *i, struct item_data *id, int *equip); + void (*preHookFunc) (unsigned char **buf, int *n, struct item **i, struct item_data **id, int *equip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_sub_pre[hIndex].func; - preHookFunc(buf, &n, i, id, &equip); + preHookFunc(&buf, &n, &i, &id, &equip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7362,10 +7387,10 @@ void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_dat HPMHooks.source.clif.item_sub(buf, n, i, id, equip); } if( HPMHooks.count.HP_clif_item_sub_post ) { - void (*postHookFunc) (unsigned char *buf, int *n, struct item *i, struct item_data *id, int *equip); + void (*postHookFunc) (unsigned char *buf, int n, struct item *i, struct item_data *id, int equip); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_sub_post[hIndex].func; - postHookFunc(buf, &n, i, id, &equip); + postHookFunc(buf, n, i, id, equip); } } return; @@ -7373,11 +7398,11 @@ void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_dat void HP_clif_getareachar_item(struct map_session_data *sd, struct flooritem_data *fitem) { int hIndex = 0; if( HPMHooks.count.HP_clif_getareachar_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem); + void (*preHookFunc) (struct map_session_data **sd, struct flooritem_data **fitem); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_getareachar_item_pre[hIndex].func; - preHookFunc(sd, fitem); + preHookFunc(&sd, &fitem); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7399,11 +7424,11 @@ void HP_clif_getareachar_item(struct map_session_data *sd, struct flooritem_data void HP_clif_cart_additem_ack(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_cart_additem_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cart_additem_ack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7414,10 +7439,10 @@ void HP_clif_cart_additem_ack(struct map_session_data *sd, int flag) { HPMHooks.source.clif.cart_additem_ack(sd, flag); } if( HPMHooks.count.HP_clif_cart_additem_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cart_additem_ack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -7451,11 +7476,11 @@ void HP_clif_cashshop_load(void) { void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid, unsigned short containerid) { int hIndex = 0; if( HPMHooks.count.HP_clif_package_announce_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *containerid); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid, unsigned short *containerid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_package_announce_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_package_announce_pre[hIndex].func; - preHookFunc(sd, &nameid, &containerid); + preHookFunc(&sd, &nameid, &containerid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7466,10 +7491,10 @@ void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid HPMHooks.source.clif.package_announce(sd, nameid, containerid); } if( HPMHooks.count.HP_clif_package_announce_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *containerid); + void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, unsigned short containerid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_package_announce_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_package_announce_post[hIndex].func; - postHookFunc(sd, &nameid, &containerid); + postHookFunc(sd, nameid, containerid); } } return; @@ -7477,11 +7502,11 @@ void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid void HP_clif_item_drop_announce(struct map_session_data *sd, unsigned short nameid, char *monsterName) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_drop_announce_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, char *monsterName); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid, char **monsterName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_drop_announce_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_drop_announce_pre[hIndex].func; - preHookFunc(sd, &nameid, monsterName); + preHookFunc(&sd, &nameid, &monsterName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7492,10 +7517,10 @@ void HP_clif_item_drop_announce(struct map_session_data *sd, unsigned short name HPMHooks.source.clif.item_drop_announce(sd, nameid, monsterName); } if( HPMHooks.count.HP_clif_item_drop_announce_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *nameid, char *monsterName); + void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, char *monsterName); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_drop_announce_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_drop_announce_post[hIndex].func; - postHookFunc(sd, &nameid, monsterName); + postHookFunc(sd, nameid, monsterName); } } return; @@ -7518,10 +7543,10 @@ void HP_clif_clearunit_single(int id, clr_type type, int fd) { HPMHooks.source.clif.clearunit_single(id, type, fd); } if( HPMHooks.count.HP_clif_clearunit_single_post ) { - void (*postHookFunc) (int *id, clr_type *type, int *fd); + void (*postHookFunc) (int id, clr_type type, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearunit_single_post[hIndex].func; - postHookFunc(&id, &type, &fd); + postHookFunc(id, type, fd); } } return; @@ -7529,11 +7554,11 @@ void HP_clif_clearunit_single(int id, clr_type type, int fd) { void HP_clif_clearunit_area(struct block_list *bl, clr_type type) { int hIndex = 0; if( HPMHooks.count.HP_clif_clearunit_area_pre ) { - void (*preHookFunc) (struct block_list *bl, clr_type *type); + void (*preHookFunc) (struct block_list **bl, clr_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_area_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_clearunit_area_pre[hIndex].func; - preHookFunc(bl, &type); + preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7544,10 +7569,10 @@ void HP_clif_clearunit_area(struct block_list *bl, clr_type type) { HPMHooks.source.clif.clearunit_area(bl, type); } if( HPMHooks.count.HP_clif_clearunit_area_post ) { - void (*postHookFunc) (struct block_list *bl, clr_type *type); + void (*postHookFunc) (struct block_list *bl, clr_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_area_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearunit_area_post[hIndex].func; - postHookFunc(bl, &type); + postHookFunc(bl, type); } } return; @@ -7555,11 +7580,11 @@ void HP_clif_clearunit_area(struct block_list *bl, clr_type type) { void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, int64 tick) { int hIndex = 0; if( HPMHooks.count.HP_clif_clearunit_delayed_pre ) { - void (*preHookFunc) (struct block_list *bl, clr_type *type, int64 *tick); + void (*preHookFunc) (struct block_list **bl, clr_type *type, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_pre[hIndex].func; - preHookFunc(bl, &type, &tick); + preHookFunc(&bl, &type, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7570,10 +7595,10 @@ void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, int64 tick) HPMHooks.source.clif.clearunit_delayed(bl, type, tick); } if( HPMHooks.count.HP_clif_clearunit_delayed_post ) { - void (*postHookFunc) (struct block_list *bl, clr_type *type, int64 *tick); + void (*postHookFunc) (struct block_list *bl, clr_type type, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_post[hIndex].func; - postHookFunc(bl, &type, &tick); + postHookFunc(bl, type, tick); } } return; @@ -7581,11 +7606,11 @@ void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, int64 tick) void HP_clif_walkok(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_walkok_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_walkok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_walkok_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7607,11 +7632,11 @@ void HP_clif_walkok(struct map_session_data *sd) { void HP_clif_move(struct unit_data *ud) { int hIndex = 0; if( HPMHooks.count.HP_clif_move_pre ) { - void (*preHookFunc) (struct unit_data *ud); + void (*preHookFunc) (struct unit_data **ud); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_move_pre[hIndex].func; - preHookFunc(ud); + preHookFunc(&ud); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7633,11 +7658,11 @@ void HP_clif_move(struct unit_data *ud) { void HP_clif_move2(struct block_list *bl, struct view_data *vd, struct unit_data *ud) { int hIndex = 0; if( HPMHooks.count.HP_clif_move2_pre ) { - void (*preHookFunc) (struct block_list *bl, struct view_data *vd, struct unit_data *ud); + void (*preHookFunc) (struct block_list **bl, struct view_data **vd, struct unit_data **ud); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_move2_pre[hIndex].func; - preHookFunc(bl, vd, ud); + preHookFunc(&bl, &vd, &ud); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7659,11 +7684,11 @@ void HP_clif_move2(struct block_list *bl, struct view_data *vd, struct unit_data void HP_clif_blown(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_blown_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_blown_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7685,11 +7710,11 @@ void HP_clif_blown(struct block_list *bl) { void HP_clif_slide(struct block_list *bl, int x, int y) { int hIndex = 0; if( HPMHooks.count.HP_clif_slide_pre ) { - void (*preHookFunc) (struct block_list *bl, int *x, int *y); + void (*preHookFunc) (struct block_list **bl, int *x, int *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_slide_pre[hIndex].func; - preHookFunc(bl, &x, &y); + preHookFunc(&bl, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7700,10 +7725,10 @@ void HP_clif_slide(struct block_list *bl, int x, int y) { HPMHooks.source.clif.slide(bl, x, y); } if( HPMHooks.count.HP_clif_slide_post ) { - void (*postHookFunc) (struct block_list *bl, int *x, int *y); + void (*postHookFunc) (struct block_list *bl, int x, int y); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_slide_post[hIndex].func; - postHookFunc(bl, &x, &y); + postHookFunc(bl, x, y); } } return; @@ -7711,11 +7736,11 @@ void HP_clif_slide(struct block_list *bl, int x, int y) { void HP_clif_fixpos(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_fixpos_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fixpos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_fixpos_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7737,11 +7762,11 @@ void HP_clif_fixpos(struct block_list *bl) { void HP_clif_changelook(struct block_list *bl, int type, int val) { int hIndex = 0; if( HPMHooks.count.HP_clif_changelook_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type, int *val); + void (*preHookFunc) (struct block_list **bl, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changelook_pre[hIndex].func; - preHookFunc(bl, &type, &val); + preHookFunc(&bl, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7752,10 +7777,10 @@ void HP_clif_changelook(struct block_list *bl, int type, int val) { HPMHooks.source.clif.changelook(bl, type, val); } if( HPMHooks.count.HP_clif_changelook_post ) { - void (*postHookFunc) (struct block_list *bl, int *type, int *val); + void (*postHookFunc) (struct block_list *bl, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changelook_post[hIndex].func; - postHookFunc(bl, &type, &val); + postHookFunc(bl, type, val); } } return; @@ -7763,11 +7788,11 @@ void HP_clif_changelook(struct block_list *bl, int type, int val) { void HP_clif_changetraplook(struct block_list *bl, int val) { int hIndex = 0; if( HPMHooks.count.HP_clif_changetraplook_pre ) { - void (*preHookFunc) (struct block_list *bl, int *val); + void (*preHookFunc) (struct block_list **bl, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changetraplook_pre[hIndex].func; - preHookFunc(bl, &val); + preHookFunc(&bl, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7778,10 +7803,10 @@ void HP_clif_changetraplook(struct block_list *bl, int val) { HPMHooks.source.clif.changetraplook(bl, val); } if( HPMHooks.count.HP_clif_changetraplook_post ) { - void (*postHookFunc) (struct block_list *bl, int *val); + void (*postHookFunc) (struct block_list *bl, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changetraplook_post[hIndex].func; - postHookFunc(bl, &val); + postHookFunc(bl, val); } } return; @@ -7789,11 +7814,11 @@ void HP_clif_changetraplook(struct block_list *bl, int val) { void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_refreshlook_pre ) { - void (*preHookFunc) (struct block_list *bl, int *id, int *type, int *val, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, int *id, int *type, int *val, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refreshlook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_refreshlook_pre[hIndex].func; - preHookFunc(bl, &id, &type, &val, &target); + preHookFunc(&bl, &id, &type, &val, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7804,10 +7829,10 @@ void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum HPMHooks.source.clif.refreshlook(bl, id, type, val, target); } if( HPMHooks.count.HP_clif_refreshlook_post ) { - void (*postHookFunc) (struct block_list *bl, int *id, int *type, int *val, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, int id, int type, int val, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refreshlook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_refreshlook_post[hIndex].func; - postHookFunc(bl, &id, &type, &val, &target); + postHookFunc(bl, id, type, val, target); } } return; @@ -7815,11 +7840,11 @@ void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum void HP_clif_sendlook(struct block_list *bl, int id, int type, int val, int val2, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_sendlook_pre ) { - void (*preHookFunc) (struct block_list *bl, int *id, int *type, int *val, int *val2, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, int *id, int *type, int *val, int *val2, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendlook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sendlook_pre[hIndex].func; - preHookFunc(bl, &id, &type, &val, &val2, &target); + preHookFunc(&bl, &id, &type, &val, &val2, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7830,10 +7855,10 @@ void HP_clif_sendlook(struct block_list *bl, int id, int type, int val, int val2 HPMHooks.source.clif.sendlook(bl, id, type, val, val2, target); } if( HPMHooks.count.HP_clif_sendlook_post ) { - void (*postHookFunc) (struct block_list *bl, int *id, int *type, int *val, int *val2, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, int id, int type, int val, int val2, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendlook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_sendlook_post[hIndex].func; - postHookFunc(bl, &id, &type, &val, &val2, &target); + postHookFunc(bl, id, type, val, val2, target); } } return; @@ -7841,11 +7866,11 @@ void HP_clif_sendlook(struct block_list *bl, int id, int type, int val, int val2 void HP_clif_class_change(struct block_list *bl, int class_, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_class_change_pre ) { - void (*preHookFunc) (struct block_list *bl, int *class_, int *type); + void (*preHookFunc) (struct block_list **bl, int *class_, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_class_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_class_change_pre[hIndex].func; - preHookFunc(bl, &class_, &type); + preHookFunc(&bl, &class_, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7856,10 +7881,10 @@ void HP_clif_class_change(struct block_list *bl, int class_, int type) { HPMHooks.source.clif.class_change(bl, class_, type); } if( HPMHooks.count.HP_clif_class_change_post ) { - void (*postHookFunc) (struct block_list *bl, int *class_, int *type); + void (*postHookFunc) (struct block_list *bl, int class_, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_class_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_class_change_post[hIndex].func; - postHookFunc(bl, &class_, &type); + postHookFunc(bl, class_, type); } } return; @@ -7867,11 +7892,11 @@ void HP_clif_class_change(struct block_list *bl, int class_, int type) { void HP_clif_skill_delunit(struct skill_unit *su) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_delunit_pre ) { - void (*preHookFunc) (struct skill_unit *su); + void (*preHookFunc) (struct skill_unit **su); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_delunit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_delunit_pre[hIndex].func; - preHookFunc(su); + preHookFunc(&su); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7893,11 +7918,11 @@ void HP_clif_skill_delunit(struct skill_unit *su) { void HP_clif_skillunit_update(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillunit_update_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillunit_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillunit_update_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7935,10 +7960,10 @@ int HP_clif_clearunit_delayed_sub(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.clif.clearunit_delayed_sub(tid, tick, id, data); } if( HPMHooks.count.HP_clif_clearunit_delayed_sub_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -7946,11 +7971,11 @@ int HP_clif_clearunit_delayed_sub(int tid, int64 tick, int id, intptr_t data) { void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_set_unit_idle_pre ) { - void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, struct map_session_data **tsd, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_set_unit_idle_pre[hIndex].func; - preHookFunc(bl, tsd, &target); + preHookFunc(&bl, &tsd, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7961,10 +7986,10 @@ void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd, HPMHooks.source.clif.set_unit_idle(bl, tsd, target); } if( HPMHooks.count.HP_clif_set_unit_idle_post ) { - void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_set_unit_idle_post[hIndex].func; - postHookFunc(bl, tsd, &target); + postHookFunc(bl, tsd, target); } } return; @@ -7972,11 +7997,11 @@ void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd, void HP_clif_spawn_unit(struct block_list *bl, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_spawn_unit_pre ) { - void (*preHookFunc) (struct block_list *bl, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spawn_unit_pre[hIndex].func; - preHookFunc(bl, &target); + preHookFunc(&bl, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -7987,10 +8012,10 @@ void HP_clif_spawn_unit(struct block_list *bl, enum send_target target) { HPMHooks.source.clif.spawn_unit(bl, target); } if( HPMHooks.count.HP_clif_spawn_unit_post ) { - void (*postHookFunc) (struct block_list *bl, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_spawn_unit_post[hIndex].func; - postHookFunc(bl, &target); + postHookFunc(bl, target); } } return; @@ -7998,11 +8023,11 @@ void HP_clif_spawn_unit(struct block_list *bl, enum send_target target) { void HP_clif_spawn_unit2(struct block_list *bl, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_spawn_unit2_pre ) { - void (*preHookFunc) (struct block_list *bl, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spawn_unit2_pre[hIndex].func; - preHookFunc(bl, &target); + preHookFunc(&bl, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8013,10 +8038,10 @@ void HP_clif_spawn_unit2(struct block_list *bl, enum send_target target) { HPMHooks.source.clif.spawn_unit2(bl, target); } if( HPMHooks.count.HP_clif_spawn_unit2_post ) { - void (*postHookFunc) (struct block_list *bl, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_spawn_unit2_post[hIndex].func; - postHookFunc(bl, &target); + postHookFunc(bl, target); } } return; @@ -8024,11 +8049,11 @@ void HP_clif_spawn_unit2(struct block_list *bl, enum send_target target) { void HP_clif_set_unit_idle2(struct block_list *bl, struct map_session_data *tsd, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_set_unit_idle2_pre ) { - void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, struct map_session_data **tsd, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_set_unit_idle2_pre[hIndex].func; - preHookFunc(bl, tsd, &target); + preHookFunc(&bl, &tsd, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8039,10 +8064,10 @@ void HP_clif_set_unit_idle2(struct block_list *bl, struct map_session_data *tsd, HPMHooks.source.clif.set_unit_idle2(bl, tsd, target); } if( HPMHooks.count.HP_clif_set_unit_idle2_post ) { - void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_set_unit_idle2_post[hIndex].func; - postHookFunc(bl, tsd, &target); + postHookFunc(bl, tsd, target); } } return; @@ -8050,11 +8075,11 @@ void HP_clif_set_unit_idle2(struct block_list *bl, struct map_session_data *tsd, void HP_clif_set_unit_walking(struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_set_unit_walking_pre ) { - void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, struct map_session_data **tsd, struct unit_data **ud, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_walking_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_set_unit_walking_pre[hIndex].func; - preHookFunc(bl, tsd, ud, &target); + preHookFunc(&bl, &tsd, &ud, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8065,10 +8090,10 @@ void HP_clif_set_unit_walking(struct block_list *bl, struct map_session_data *ts HPMHooks.source.clif.set_unit_walking(bl, tsd, ud, target); } if( HPMHooks.count.HP_clif_set_unit_walking_post ) { - void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_walking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_set_unit_walking_post[hIndex].func; - postHookFunc(bl, tsd, ud, &target); + postHookFunc(bl, tsd, ud, target); } } return; @@ -8077,11 +8102,11 @@ int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damag int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_calc_walkdelay_pre ) { - int (*preHookFunc) (struct block_list *bl, int *delay, int *type, int *damage, int *div_); + int (*preHookFunc) (struct block_list **bl, int *delay, int *type, int *damage, int *div_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_calc_walkdelay_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_calc_walkdelay_pre[hIndex].func; - retVal___ = preHookFunc(bl, &delay, &type, &damage, &div_); + retVal___ = preHookFunc(&bl, &delay, &type, &damage, &div_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8092,10 +8117,10 @@ int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damag retVal___ = HPMHooks.source.clif.calc_walkdelay(bl, delay, type, damage, div_); } if( HPMHooks.count.HP_clif_calc_walkdelay_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *delay, int *type, int *damage, int *div_); + int (*postHookFunc) (int retVal___, struct block_list *bl, int delay, int type, int damage, int div_); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_calc_walkdelay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_calc_walkdelay_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &delay, &type, &damage, &div_); + retVal___ = postHookFunc(retVal___, bl, delay, type, damage, div_); } } return retVal___; @@ -8103,11 +8128,11 @@ int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damag void HP_clif_getareachar_skillunit(struct block_list *bl, struct skill_unit *su, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_getareachar_skillunit_pre ) { - void (*preHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, struct skill_unit **su, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_pre[hIndex].func; - preHookFunc(bl, su, &target); + preHookFunc(&bl, &su, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8118,10 +8143,10 @@ void HP_clif_getareachar_skillunit(struct block_list *bl, struct skill_unit *su, HPMHooks.source.clif.getareachar_skillunit(bl, su, target); } if( HPMHooks.count.HP_clif_getareachar_skillunit_post ) { - void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_post[hIndex].func; - postHookFunc(bl, su, &target); + postHookFunc(bl, su, target); } } return; @@ -8129,11 +8154,11 @@ void HP_clif_getareachar_skillunit(struct block_list *bl, struct skill_unit *su, void HP_clif_getareachar_unit(struct map_session_data *sd, struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_getareachar_unit_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_unit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_getareachar_unit_pre[hIndex].func; - preHookFunc(sd, bl); + preHookFunc(&sd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8155,11 +8180,11 @@ void HP_clif_getareachar_unit(struct map_session_data *sd, struct block_list *bl void HP_clif_clearchar_skillunit(struct skill_unit *su, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_clearchar_skillunit_pre ) { - void (*preHookFunc) (struct skill_unit *su, int *fd); + void (*preHookFunc) (struct skill_unit **su, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchar_skillunit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_clearchar_skillunit_pre[hIndex].func; - preHookFunc(su, &fd); + preHookFunc(&su, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8170,10 +8195,10 @@ void HP_clif_clearchar_skillunit(struct skill_unit *su, int fd) { HPMHooks.source.clif.clearchar_skillunit(su, fd); } if( HPMHooks.count.HP_clif_clearchar_skillunit_post ) { - void (*postHookFunc) (struct skill_unit *su, int *fd); + void (*postHookFunc) (struct skill_unit *su, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchar_skillunit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearchar_skillunit_post[hIndex].func; - postHookFunc(su, &fd); + postHookFunc(su, fd); } } return; @@ -8182,12 +8207,12 @@ int HP_clif_getareachar(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_getareachar_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_getareachar_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -8214,11 +8239,11 @@ int HP_clif_getareachar(struct block_list *bl, va_list ap) { void HP_clif_graffiti_entry(struct block_list *bl, struct skill_unit *su, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_graffiti_entry_pre ) { - void (*preHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, struct skill_unit **su, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_graffiti_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_graffiti_entry_pre[hIndex].func; - preHookFunc(bl, su, &target); + preHookFunc(&bl, &su, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8229,10 +8254,10 @@ void HP_clif_graffiti_entry(struct block_list *bl, struct skill_unit *su, enum s HPMHooks.source.clif.graffiti_entry(bl, su, target); } if( HPMHooks.count.HP_clif_graffiti_entry_post ) { - void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_graffiti_entry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_graffiti_entry_post[hIndex].func; - postHookFunc(bl, su, &target); + postHookFunc(bl, su, target); } } return; @@ -8241,11 +8266,11 @@ bool HP_clif_spawn(struct block_list *bl) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_clif_spawn_pre ) { - bool (*preHookFunc) (struct block_list *bl); + bool (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spawn_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8267,11 +8292,11 @@ bool HP_clif_spawn(struct block_list *bl) { void HP_clif_changemap(struct map_session_data *sd, short m, int x, int y) { int hIndex = 0; if( HPMHooks.count.HP_clif_changemap_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *m, int *x, int *y); + void (*preHookFunc) (struct map_session_data **sd, short *m, int *x, int *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changemap_pre[hIndex].func; - preHookFunc(sd, &m, &x, &y); + preHookFunc(&sd, &m, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8282,10 +8307,10 @@ void HP_clif_changemap(struct map_session_data *sd, short m, int x, int y) { HPMHooks.source.clif.changemap(sd, m, x, y); } if( HPMHooks.count.HP_clif_changemap_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *m, int *x, int *y); + void (*postHookFunc) (struct map_session_data *sd, short m, int x, int y); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changemap_post[hIndex].func; - postHookFunc(sd, &m, &x, &y); + postHookFunc(sd, m, x, y); } } return; @@ -8308,10 +8333,10 @@ void HP_clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_ta HPMHooks.source.clif.changemapcell(fd, m, x, y, type, target); } if( HPMHooks.count.HP_clif_changemapcell_post ) { - void (*postHookFunc) (int *fd, int16 *m, int *x, int *y, int *type, enum send_target *target); + void (*postHookFunc) (int fd, int16 m, int x, int y, int type, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changemapcell_post[hIndex].func; - postHookFunc(&fd, &m, &x, &y, &type, &target); + postHookFunc(fd, m, x, y, type, target); } } return; @@ -8319,11 +8344,11 @@ void HP_clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_ta void HP_clif_map_property(struct map_session_data *sd, enum map_property property) { int hIndex = 0; if( HPMHooks.count.HP_clif_map_property_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum map_property *property); + void (*preHookFunc) (struct map_session_data **sd, enum map_property *property); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_map_property_pre[hIndex].func; - preHookFunc(sd, &property); + preHookFunc(&sd, &property); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8334,10 +8359,10 @@ void HP_clif_map_property(struct map_session_data *sd, enum map_property propert HPMHooks.source.clif.map_property(sd, property); } if( HPMHooks.count.HP_clif_map_property_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum map_property *property); + void (*postHookFunc) (struct map_session_data *sd, enum map_property property); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_map_property_post[hIndex].func; - postHookFunc(sd, &property); + postHookFunc(sd, property); } } return; @@ -8345,11 +8370,11 @@ void HP_clif_map_property(struct map_session_data *sd, enum map_property propert void HP_clif_pvpset(struct map_session_data *sd, int pvprank, int pvpnum, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_pvpset_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *pvprank, int *pvpnum, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *pvprank, int *pvpnum, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pvpset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pvpset_pre[hIndex].func; - preHookFunc(sd, &pvprank, &pvpnum, &type); + preHookFunc(&sd, &pvprank, &pvpnum, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8360,10 +8385,10 @@ void HP_clif_pvpset(struct map_session_data *sd, int pvprank, int pvpnum, int ty HPMHooks.source.clif.pvpset(sd, pvprank, pvpnum, type); } if( HPMHooks.count.HP_clif_pvpset_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *pvprank, int *pvpnum, int *type); + void (*postHookFunc) (struct map_session_data *sd, int pvprank, int pvpnum, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pvpset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pvpset_post[hIndex].func; - postHookFunc(sd, &pvprank, &pvpnum, &type); + postHookFunc(sd, pvprank, pvpnum, type); } } return; @@ -8386,10 +8411,10 @@ void HP_clif_map_property_mapall(int mapid, enum map_property property) { HPMHooks.source.clif.map_property_mapall(mapid, property); } if( HPMHooks.count.HP_clif_map_property_mapall_post ) { - void (*postHookFunc) (int *mapid, enum map_property *property); + void (*postHookFunc) (int mapid, enum map_property property); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_mapall_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_map_property_mapall_post[hIndex].func; - postHookFunc(&mapid, &property); + postHookFunc(mapid, property); } } return; @@ -8397,11 +8422,11 @@ void HP_clif_map_property_mapall(int mapid, enum map_property property) { void HP_clif_bossmapinfo(int fd, struct mob_data *md, short flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_bossmapinfo_pre ) { - void (*preHookFunc) (int *fd, struct mob_data *md, short *flag); + void (*preHookFunc) (int *fd, struct mob_data **md, short *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bossmapinfo_pre[hIndex].func; - preHookFunc(&fd, md, &flag); + preHookFunc(&fd, &md, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8412,10 +8437,10 @@ void HP_clif_bossmapinfo(int fd, struct mob_data *md, short flag) { HPMHooks.source.clif.bossmapinfo(fd, md, flag); } if( HPMHooks.count.HP_clif_bossmapinfo_post ) { - void (*postHookFunc) (int *fd, struct mob_data *md, short *flag); + void (*postHookFunc) (int fd, struct mob_data *md, short flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bossmapinfo_post[hIndex].func; - postHookFunc(&fd, md, &flag); + postHookFunc(fd, md, flag); } } return; @@ -8423,11 +8448,11 @@ void HP_clif_bossmapinfo(int fd, struct mob_data *md, short flag) { void HP_clif_map_type(struct map_session_data *sd, enum map_type type) { int hIndex = 0; if( HPMHooks.count.HP_clif_map_type_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum map_type *type); + void (*preHookFunc) (struct map_session_data **sd, enum map_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_type_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_map_type_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8438,10 +8463,10 @@ void HP_clif_map_type(struct map_session_data *sd, enum map_type type) { HPMHooks.source.clif.map_type(sd, type); } if( HPMHooks.count.HP_clif_map_type_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum map_type *type); + void (*postHookFunc) (struct map_session_data *sd, enum map_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_map_type_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -8449,11 +8474,11 @@ void HP_clif_map_type(struct map_session_data *sd, enum map_type type) { void HP_clif_maptypeproperty2(struct block_list *bl, enum send_target t) { int hIndex = 0; if( HPMHooks.count.HP_clif_maptypeproperty2_pre ) { - void (*preHookFunc) (struct block_list *bl, enum send_target *t); + void (*preHookFunc) (struct block_list **bl, enum send_target *t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_pre[hIndex].func; - preHookFunc(bl, &t); + preHookFunc(&bl, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8464,10 +8489,10 @@ void HP_clif_maptypeproperty2(struct block_list *bl, enum send_target t) { HPMHooks.source.clif.maptypeproperty2(bl, t); } if( HPMHooks.count.HP_clif_maptypeproperty2_post ) { - void (*postHookFunc) (struct block_list *bl, enum send_target *t); + void (*postHookFunc) (struct block_list *bl, enum send_target t); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_post[hIndex].func; - postHookFunc(bl, &t); + postHookFunc(bl, t); } } return; @@ -8475,11 +8500,11 @@ void HP_clif_maptypeproperty2(struct block_list *bl, enum send_target t) { void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port) { int hIndex = 0; if( HPMHooks.count.HP_clif_changemapserver_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapserver_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changemapserver_pre[hIndex].func; - preHookFunc(sd, &map_index, &x, &y, &ip, &port); + preHookFunc(&sd, &map_index, &x, &y, &ip, &port); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8490,10 +8515,10 @@ void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_ind HPMHooks.source.clif.changemapserver(sd, map_index, x, y, ip, port); } if( HPMHooks.count.HP_clif_changemapserver_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port); + void (*postHookFunc) (struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapserver_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changemapserver_post[hIndex].func; - postHookFunc(sd, &map_index, &x, &y, &ip, &port); + postHookFunc(sd, map_index, x, y, ip, port); } } return; @@ -8501,11 +8526,11 @@ void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_ind void HP_clif_npcbuysell(struct map_session_data *sd, int id) { int hIndex = 0; if( HPMHooks.count.HP_clif_npcbuysell_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *id); + void (*preHookFunc) (struct map_session_data **sd, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_npcbuysell_pre[hIndex].func; - preHookFunc(sd, &id); + preHookFunc(&sd, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8516,10 +8541,10 @@ void HP_clif_npcbuysell(struct map_session_data *sd, int id) { HPMHooks.source.clif.npcbuysell(sd, id); } if( HPMHooks.count.HP_clif_npcbuysell_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *id); + void (*postHookFunc) (struct map_session_data *sd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_npcbuysell_post[hIndex].func; - postHookFunc(sd, &id); + postHookFunc(sd, id); } } return; @@ -8527,11 +8552,11 @@ void HP_clif_npcbuysell(struct map_session_data *sd, int id) { void HP_clif_buylist(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buylist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buylist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buylist_pre[hIndex].func; - preHookFunc(sd, nd); + preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8553,11 +8578,11 @@ void HP_clif_buylist(struct map_session_data *sd, struct npc_data *nd) { void HP_clif_selllist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_selllist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selllist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_selllist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8579,11 +8604,11 @@ void HP_clif_selllist(struct map_session_data *sd) { void HP_clif_cashshop_show(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_clif_cashshop_show_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_show_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cashshop_show_pre[hIndex].func; - preHookFunc(sd, nd); + preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8605,11 +8630,11 @@ void HP_clif_cashshop_show(struct map_session_data *sd, struct npc_data *nd) { void HP_clif_npc_buy_result(struct map_session_data *sd, unsigned char result) { int hIndex = 0; if( HPMHooks.count.HP_clif_npc_buy_result_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *result); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_buy_result_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_npc_buy_result_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8620,10 +8645,10 @@ void HP_clif_npc_buy_result(struct map_session_data *sd, unsigned char result) { HPMHooks.source.clif.npc_buy_result(sd, result); } if( HPMHooks.count.HP_clif_npc_buy_result_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *result); + void (*postHookFunc) (struct map_session_data *sd, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_buy_result_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_npc_buy_result_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -8631,11 +8656,11 @@ void HP_clif_npc_buy_result(struct map_session_data *sd, unsigned char result) { void HP_clif_npc_sell_result(struct map_session_data *sd, unsigned char result) { int hIndex = 0; if( HPMHooks.count.HP_clif_npc_sell_result_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *result); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_sell_result_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_npc_sell_result_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8646,10 +8671,10 @@ void HP_clif_npc_sell_result(struct map_session_data *sd, unsigned char result) HPMHooks.source.clif.npc_sell_result(sd, result); } if( HPMHooks.count.HP_clif_npc_sell_result_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *result); + void (*postHookFunc) (struct map_session_data *sd, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_sell_result_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_npc_sell_result_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -8657,11 +8682,11 @@ void HP_clif_npc_sell_result(struct map_session_data *sd, unsigned char result) void HP_clif_cashshop_ack(struct map_session_data *sd, int error) { int hIndex = 0; if( HPMHooks.count.HP_clif_cashshop_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *error); + void (*preHookFunc) (struct map_session_data **sd, int *error); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cashshop_ack_pre[hIndex].func; - preHookFunc(sd, &error); + preHookFunc(&sd, &error); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8672,10 +8697,10 @@ void HP_clif_cashshop_ack(struct map_session_data *sd, int error) { HPMHooks.source.clif.cashshop_ack(sd, error); } if( HPMHooks.count.HP_clif_cashshop_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *error); + void (*postHookFunc) (struct map_session_data *sd, int error); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cashshop_ack_post[hIndex].func; - postHookFunc(sd, &error); + postHookFunc(sd, error); } } return; @@ -8683,11 +8708,11 @@ void HP_clif_cashshop_ack(struct map_session_data *sd, int error) { void HP_clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptmes_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid, const char *mes); + void (*preHookFunc) (struct map_session_data **sd, int *npcid, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptmes_pre[hIndex].func; - preHookFunc(sd, &npcid, mes); + preHookFunc(&sd, &npcid, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8698,10 +8723,10 @@ void HP_clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) HPMHooks.source.clif.scriptmes(sd, npcid, mes); } if( HPMHooks.count.HP_clif_scriptmes_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid, const char *mes); + void (*postHookFunc) (struct map_session_data *sd, int npcid, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptmes_post[hIndex].func; - postHookFunc(sd, &npcid, mes); + postHookFunc(sd, npcid, mes); } } return; @@ -8709,11 +8734,11 @@ void HP_clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) void HP_clif_scriptnext(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptnext_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptnext_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8724,10 +8749,10 @@ void HP_clif_scriptnext(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.scriptnext(sd, npcid); } if( HPMHooks.count.HP_clif_scriptnext_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptnext_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8735,11 +8760,11 @@ void HP_clif_scriptnext(struct map_session_data *sd, int npcid) { void HP_clif_scriptclose(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptclose_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptclose_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8750,10 +8775,10 @@ void HP_clif_scriptclose(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.scriptclose(sd, npcid); } if( HPMHooks.count.HP_clif_scriptclose_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptclose_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8761,11 +8786,11 @@ void HP_clif_scriptclose(struct map_session_data *sd, int npcid) { void HP_clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptmenu_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid, const char *mes); + void (*preHookFunc) (struct map_session_data **sd, int *npcid, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptmenu_pre[hIndex].func; - preHookFunc(sd, &npcid, mes); + preHookFunc(&sd, &npcid, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8776,10 +8801,10 @@ void HP_clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) HPMHooks.source.clif.scriptmenu(sd, npcid, mes); } if( HPMHooks.count.HP_clif_scriptmenu_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid, const char *mes); + void (*postHookFunc) (struct map_session_data *sd, int npcid, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptmenu_post[hIndex].func; - postHookFunc(sd, &npcid, mes); + postHookFunc(sd, npcid, mes); } } return; @@ -8787,11 +8812,11 @@ void HP_clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) void HP_clif_scriptinput(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptinput_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptinput_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8802,10 +8827,10 @@ void HP_clif_scriptinput(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.scriptinput(sd, npcid); } if( HPMHooks.count.HP_clif_scriptinput_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptinput_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8813,11 +8838,11 @@ void HP_clif_scriptinput(struct map_session_data *sd, int npcid) { void HP_clif_scriptinputstr(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptinputstr_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptinputstr_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8828,10 +8853,10 @@ void HP_clif_scriptinputstr(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.scriptinputstr(sd, npcid); } if( HPMHooks.count.HP_clif_scriptinputstr_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptinputstr_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8839,11 +8864,11 @@ void HP_clif_scriptinputstr(struct map_session_data *sd, int npcid) { void HP_clif_cutin(struct map_session_data *sd, const char *image, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_cutin_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *image, int *type); + void (*preHookFunc) (struct map_session_data **sd, const char **image, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cutin_pre[hIndex].func; - preHookFunc(sd, image, &type); + preHookFunc(&sd, &image, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8854,10 +8879,10 @@ void HP_clif_cutin(struct map_session_data *sd, const char *image, int type) { HPMHooks.source.clif.cutin(sd, image, type); } if( HPMHooks.count.HP_clif_cutin_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *image, int *type); + void (*postHookFunc) (struct map_session_data *sd, const char *image, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cutin_post[hIndex].func; - postHookFunc(sd, image, &type); + postHookFunc(sd, image, type); } } return; @@ -8865,11 +8890,11 @@ void HP_clif_cutin(struct map_session_data *sd, const char *image, int type) { void HP_clif_sendfakenpc(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_sendfakenpc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sendfakenpc_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8880,10 +8905,10 @@ void HP_clif_sendfakenpc(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.sendfakenpc(sd, npcid); } if( HPMHooks.count.HP_clif_sendfakenpc_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_sendfakenpc_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8891,11 +8916,11 @@ void HP_clif_sendfakenpc(struct map_session_data *sd, int npcid) { void HP_clif_scriptclear(struct map_session_data *sd, int npcid) { int hIndex = 0; if( HPMHooks.count.HP_clif_scriptclear_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npcid); + void (*preHookFunc) (struct map_session_data **sd, int *npcid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_scriptclear_pre[hIndex].func; - preHookFunc(sd, &npcid); + preHookFunc(&sd, &npcid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8906,10 +8931,10 @@ void HP_clif_scriptclear(struct map_session_data *sd, int npcid) { HPMHooks.source.clif.scriptclear(sd, npcid); } if( HPMHooks.count.HP_clif_scriptclear_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npcid); + void (*postHookFunc) (struct map_session_data *sd, int npcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_scriptclear_post[hIndex].func; - postHookFunc(sd, &npcid); + postHookFunc(sd, npcid); } } return; @@ -8917,11 +8942,11 @@ void HP_clif_scriptclear(struct map_session_data *sd, int npcid) { void HP_clif_viewpoint(struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color) { int hIndex = 0; if( HPMHooks.count.HP_clif_viewpoint_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *npc_id, int *type, int *x, int *y, int *id, int *color); + void (*preHookFunc) (struct map_session_data **sd, int *npc_id, int *type, int *x, int *y, int *id, int *color); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewpoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_viewpoint_pre[hIndex].func; - preHookFunc(sd, &npc_id, &type, &x, &y, &id, &color); + preHookFunc(&sd, &npc_id, &type, &x, &y, &id, &color); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8932,10 +8957,10 @@ void HP_clif_viewpoint(struct map_session_data *sd, int npc_id, int type, int x, HPMHooks.source.clif.viewpoint(sd, npc_id, type, x, y, id, color); } if( HPMHooks.count.HP_clif_viewpoint_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *npc_id, int *type, int *x, int *y, int *id, int *color); + void (*postHookFunc) (struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewpoint_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_viewpoint_post[hIndex].func; - postHookFunc(sd, &npc_id, &type, &x, &y, &id, &color); + postHookFunc(sd, npc_id, type, x, y, id, color); } } return; @@ -8944,11 +8969,11 @@ int HP_clif_damage(struct block_list *src, struct block_list *dst, int sdelay, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_damage_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); + int (*preHookFunc) (struct block_list **src, struct block_list **dst, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, dst, &sdelay, &ddelay, &damage, &div, &type, &damage2); + retVal___ = preHookFunc(&src, &dst, &sdelay, &ddelay, &damage, &div, &type, &damage2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8959,10 +8984,10 @@ int HP_clif_damage(struct block_list *src, struct block_list *dst, int sdelay, i retVal___ = HPMHooks.source.clif.damage(src, dst, sdelay, ddelay, damage, div, type, damage2); } if( HPMHooks.count.HP_clif_damage_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, dst, &sdelay, &ddelay, &damage, &div, &type, &damage2); + retVal___ = postHookFunc(retVal___, src, dst, sdelay, ddelay, damage, div, type, damage2); } } return retVal___; @@ -8970,11 +8995,11 @@ int HP_clif_damage(struct block_list *src, struct block_list *dst, int sdelay, i void HP_clif_sitting(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_sitting_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sitting_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sitting_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -8996,11 +9021,11 @@ void HP_clif_sitting(struct block_list *bl) { void HP_clif_standing(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_standing_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_standing_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_standing_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9022,11 +9047,11 @@ void HP_clif_standing(struct block_list *bl) { void HP_clif_arrow_create_list(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_arrow_create_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_create_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_arrow_create_list_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9048,11 +9073,11 @@ void HP_clif_arrow_create_list(struct map_session_data *sd) { void HP_clif_refresh_storagewindow(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_refresh_storagewindow_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_storagewindow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_refresh_storagewindow_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9074,11 +9099,11 @@ void HP_clif_refresh_storagewindow(struct map_session_data *sd) { void HP_clif_refresh(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_refresh_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_refresh_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9100,11 +9125,11 @@ void HP_clif_refresh(struct map_session_data *sd) { void HP_clif_fame_blacksmith(struct map_session_data *sd, int points) { int hIndex = 0; if( HPMHooks.count.HP_clif_fame_blacksmith_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *points); + void (*preHookFunc) (struct map_session_data **sd, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_blacksmith_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_fame_blacksmith_pre[hIndex].func; - preHookFunc(sd, &points); + preHookFunc(&sd, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9115,10 +9140,10 @@ void HP_clif_fame_blacksmith(struct map_session_data *sd, int points) { HPMHooks.source.clif.fame_blacksmith(sd, points); } if( HPMHooks.count.HP_clif_fame_blacksmith_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *points); + void (*postHookFunc) (struct map_session_data *sd, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_blacksmith_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_fame_blacksmith_post[hIndex].func; - postHookFunc(sd, &points); + postHookFunc(sd, points); } } return; @@ -9126,11 +9151,11 @@ void HP_clif_fame_blacksmith(struct map_session_data *sd, int points) { void HP_clif_fame_alchemist(struct map_session_data *sd, int points) { int hIndex = 0; if( HPMHooks.count.HP_clif_fame_alchemist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *points); + void (*preHookFunc) (struct map_session_data **sd, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_alchemist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_fame_alchemist_pre[hIndex].func; - preHookFunc(sd, &points); + preHookFunc(&sd, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9141,10 +9166,10 @@ void HP_clif_fame_alchemist(struct map_session_data *sd, int points) { HPMHooks.source.clif.fame_alchemist(sd, points); } if( HPMHooks.count.HP_clif_fame_alchemist_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *points); + void (*postHookFunc) (struct map_session_data *sd, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_alchemist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_fame_alchemist_post[hIndex].func; - postHookFunc(sd, &points); + postHookFunc(sd, points); } } return; @@ -9152,11 +9177,11 @@ void HP_clif_fame_alchemist(struct map_session_data *sd, int points) { void HP_clif_fame_taekwon(struct map_session_data *sd, int points) { int hIndex = 0; if( HPMHooks.count.HP_clif_fame_taekwon_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *points); + void (*preHookFunc) (struct map_session_data **sd, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_taekwon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_fame_taekwon_pre[hIndex].func; - preHookFunc(sd, &points); + preHookFunc(&sd, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9167,10 +9192,10 @@ void HP_clif_fame_taekwon(struct map_session_data *sd, int points) { HPMHooks.source.clif.fame_taekwon(sd, points); } if( HPMHooks.count.HP_clif_fame_taekwon_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *points); + void (*postHookFunc) (struct map_session_data *sd, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_taekwon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_fame_taekwon_post[hIndex].func; - postHookFunc(sd, &points); + postHookFunc(sd, points); } } return; @@ -9178,11 +9203,11 @@ void HP_clif_fame_taekwon(struct map_session_data *sd, int points) { void HP_clif_ranklist(struct map_session_data *sd, enum fame_list_type type) { int hIndex = 0; if( HPMHooks.count.HP_clif_ranklist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum fame_list_type *type); + void (*preHookFunc) (struct map_session_data **sd, enum fame_list_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_ranklist_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9193,10 +9218,10 @@ void HP_clif_ranklist(struct map_session_data *sd, enum fame_list_type type) { HPMHooks.source.clif.ranklist(sd, type); } if( HPMHooks.count.HP_clif_ranklist_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type *type); + void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_ranklist_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -9204,11 +9229,11 @@ void HP_clif_ranklist(struct map_session_data *sd, enum fame_list_type type) { void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_type type, int points) { int hIndex = 0; if( HPMHooks.count.HP_clif_update_rankingpoint_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum fame_list_type *type, int *points); + void (*preHookFunc) (struct map_session_data **sd, enum fame_list_type *type, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_update_rankingpoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_update_rankingpoint_pre[hIndex].func; - preHookFunc(sd, &type, &points); + preHookFunc(&sd, &type, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9219,10 +9244,10 @@ void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_typ HPMHooks.source.clif.update_rankingpoint(sd, type, points); } if( HPMHooks.count.HP_clif_update_rankingpoint_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type *type, int *points); + void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type type, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_update_rankingpoint_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_update_rankingpoint_post[hIndex].func; - postHookFunc(sd, &type, &points); + postHookFunc(sd, type, points); } } return; @@ -9230,11 +9255,11 @@ void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_typ void HP_clif_pRanklist(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRanklist_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRanklist_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9245,10 +9270,10 @@ void HP_clif_pRanklist(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRanklist(fd, sd); } if( HPMHooks.count.HP_clif_pRanklist_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRanklist_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -9256,11 +9281,11 @@ void HP_clif_pRanklist(int fd, struct map_session_data *sd) { void HP_clif_hotkeys(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_hotkeys_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hotkeys_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_hotkeys_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9283,12 +9308,12 @@ int HP_clif_insight(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_insight_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insight_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_insight_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -9316,12 +9341,12 @@ int HP_clif_outsight(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_outsight_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_outsight_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_outsight_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -9348,11 +9373,11 @@ int HP_clif_outsight(struct block_list *bl, va_list ap) { void HP_clif_skillcastcancel(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillcastcancel_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcastcancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillcastcancel_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9374,11 +9399,11 @@ void HP_clif_skillcastcancel(struct block_list *bl) { void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_fail_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_fail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_fail_pre[hIndex].func; - preHookFunc(sd, &skill_id, &cause, &btype); + preHookFunc(&sd, &skill_id, &cause, &btype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9389,10 +9414,10 @@ void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum usesk HPMHooks.source.clif.skill_fail(sd, skill_id, cause, btype); } if( HPMHooks.count.HP_clif_skill_fail_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_fail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_fail_post[hIndex].func; - postHookFunc(sd, &skill_id, &cause, &btype); + postHookFunc(sd, skill_id, cause, btype); } } return; @@ -9400,11 +9425,11 @@ void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum usesk void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int duration) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_cooldown_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, unsigned int *duration); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, unsigned int *duration); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_cooldown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_cooldown_pre[hIndex].func; - preHookFunc(sd, &skill_id, &duration); + preHookFunc(&sd, &skill_id, &duration); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9415,10 +9440,10 @@ void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsign HPMHooks.source.clif.skill_cooldown(sd, skill_id, duration); } if( HPMHooks.count.HP_clif_skill_cooldown_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, unsigned int *duration); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, unsigned int duration); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_cooldown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_cooldown_post[hIndex].func; - postHookFunc(sd, &skill_id, &duration); + postHookFunc(sd, skill_id, duration); } } return; @@ -9426,11 +9451,11 @@ void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsign void HP_clif_skill_memomessage(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_memomessage_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_memomessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_memomessage_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9441,10 +9466,10 @@ void HP_clif_skill_memomessage(struct map_session_data *sd, int type) { HPMHooks.source.clif.skill_memomessage(sd, type); } if( HPMHooks.count.HP_clif_skill_memomessage_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_memomessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_memomessage_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -9452,11 +9477,11 @@ void HP_clif_skill_memomessage(struct map_session_data *sd, int type) { void HP_clif_skill_mapinfomessage(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_mapinfomessage_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_mapinfomessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_mapinfomessage_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9467,10 +9492,10 @@ void HP_clif_skill_mapinfomessage(struct map_session_data *sd, int type) { HPMHooks.source.clif.skill_mapinfomessage(sd, type); } if( HPMHooks.count.HP_clif_skill_mapinfomessage_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_mapinfomessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_mapinfomessage_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -9478,11 +9503,11 @@ void HP_clif_skill_mapinfomessage(struct map_session_data *sd, int type) { void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, int trigger) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_produce_mix_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *trigger); + void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *trigger); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_produce_mix_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_produce_mix_list_pre[hIndex].func; - preHookFunc(sd, &skill_id, &trigger); + preHookFunc(&sd, &skill_id, &trigger); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9493,10 +9518,10 @@ void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, i HPMHooks.source.clif.skill_produce_mix_list(sd, skill_id, trigger); } if( HPMHooks.count.HP_clif_skill_produce_mix_list_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *trigger); + void (*postHookFunc) (struct map_session_data *sd, int skill_id, int trigger); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_produce_mix_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_produce_mix_list_post[hIndex].func; - postHookFunc(sd, &skill_id, &trigger); + postHookFunc(sd, skill_id, trigger); } } return; @@ -9504,11 +9529,11 @@ void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, i void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type) { int hIndex = 0; if( HPMHooks.count.HP_clif_cooking_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *trigger, uint16 *skill_id, int *qty, int *list_type); + void (*preHookFunc) (struct map_session_data **sd, int *trigger, uint16 *skill_id, int *qty, int *list_type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooking_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cooking_list_pre[hIndex].func; - preHookFunc(sd, &trigger, &skill_id, &qty, &list_type); + preHookFunc(&sd, &trigger, &skill_id, &qty, &list_type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9519,10 +9544,10 @@ void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill HPMHooks.source.clif.cooking_list(sd, trigger, skill_id, qty, list_type); } if( HPMHooks.count.HP_clif_cooking_list_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *trigger, uint16 *skill_id, int *qty, int *list_type); + void (*postHookFunc) (struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooking_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cooking_list_post[hIndex].func; - postHookFunc(sd, &trigger, &skill_id, &qty, &list_type); + postHookFunc(sd, trigger, skill_id, qty, list_type); } } return; @@ -9530,11 +9555,11 @@ void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill void HP_clif_autospell(struct map_session_data *sd, uint16 skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_clif_autospell_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_autospell_pre[hIndex].func; - preHookFunc(sd, &skill_lv); + preHookFunc(&sd, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9545,10 +9570,10 @@ void HP_clif_autospell(struct map_session_data *sd, uint16 skill_lv) { HPMHooks.source.clif.autospell(sd, skill_lv); } if( HPMHooks.count.HP_clif_autospell_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_lv); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_autospell_post[hIndex].func; - postHookFunc(sd, &skill_lv); + postHookFunc(sd, skill_lv); } } return; @@ -9556,11 +9581,11 @@ void HP_clif_autospell(struct map_session_data *sd, uint16 skill_lv) { void HP_clif_combo_delay(struct block_list *bl, int wait) { int hIndex = 0; if( HPMHooks.count.HP_clif_combo_delay_pre ) { - void (*preHookFunc) (struct block_list *bl, int *wait); + void (*preHookFunc) (struct block_list **bl, int *wait); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_combo_delay_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_combo_delay_pre[hIndex].func; - preHookFunc(bl, &wait); + preHookFunc(&bl, &wait); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9571,10 +9596,10 @@ void HP_clif_combo_delay(struct block_list *bl, int wait) { HPMHooks.source.clif.combo_delay(bl, wait); } if( HPMHooks.count.HP_clif_combo_delay_post ) { - void (*postHookFunc) (struct block_list *bl, int *wait); + void (*postHookFunc) (struct block_list *bl, int wait); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_combo_delay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_combo_delay_post[hIndex].func; - postHookFunc(bl, &wait); + postHookFunc(bl, wait); } } return; @@ -9582,11 +9607,11 @@ void HP_clif_combo_delay(struct block_list *bl, int wait) { void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3) { int hIndex = 0; if( HPMHooks.count.HP_clif_status_change_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3); + void (*preHookFunc) (struct block_list **bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_status_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_status_change_pre[hIndex].func; - preHookFunc(bl, &type, &flag, &tick, &val1, &val2, &val3); + preHookFunc(&bl, &type, &flag, &tick, &val1, &val2, &val3); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9597,10 +9622,10 @@ void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick, HPMHooks.source.clif.status_change(bl, type, flag, tick, val1, val2, val3); } if( HPMHooks.count.HP_clif_status_change_post ) { - void (*postHookFunc) (struct block_list *bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3); + void (*postHookFunc) (struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_status_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_status_change_post[hIndex].func; - postHookFunc(bl, &type, &flag, &tick, &val1, &val2, &val3); + postHookFunc(bl, type, flag, tick, val1, val2, val3); } } return; @@ -9608,11 +9633,11 @@ void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick, void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_card, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_insert_card_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx_equip, int *idx_card, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *idx_equip, int *idx_card, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insert_card_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_insert_card_pre[hIndex].func; - preHookFunc(sd, &idx_equip, &idx_card, &flag); + preHookFunc(&sd, &idx_equip, &idx_card, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9623,10 +9648,10 @@ void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_car HPMHooks.source.clif.insert_card(sd, idx_equip, idx_card, flag); } if( HPMHooks.count.HP_clif_insert_card_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx_equip, int *idx_card, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int idx_equip, int idx_card, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insert_card_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_insert_card_post[hIndex].func; - postHookFunc(sd, &idx_equip, &idx_card, &flag); + postHookFunc(sd, idx_equip, idx_card, flag); } } return; @@ -9634,11 +9659,11 @@ void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_car void HP_clif_inventorylist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_inventorylist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_inventorylist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_inventorylist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9660,11 +9685,11 @@ void HP_clif_inventorylist(struct map_session_data *sd) { void HP_clif_equiplist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_equiplist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiplist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_equiplist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9686,11 +9711,11 @@ void HP_clif_equiplist(struct map_session_data *sd) { void HP_clif_cartlist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_cartlist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cartlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cartlist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9712,11 +9737,11 @@ void HP_clif_cartlist(struct map_session_data *sd) { void HP_clif_favorite_item(struct map_session_data *sd, unsigned short index) { int hIndex = 0; if( HPMHooks.count.HP_clif_favorite_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *index); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_favorite_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_favorite_item_pre[hIndex].func; - preHookFunc(sd, &index); + preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9727,10 +9752,10 @@ void HP_clif_favorite_item(struct map_session_data *sd, unsigned short index) { HPMHooks.source.clif.favorite_item(sd, index); } if( HPMHooks.count.HP_clif_favorite_item_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *index); + void (*postHookFunc) (struct map_session_data *sd, unsigned short index); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_favorite_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_favorite_item_post[hIndex].func; - postHookFunc(sd, &index); + postHookFunc(sd, index); } } return; @@ -9753,10 +9778,10 @@ void HP_clif_clearcart(int fd) { HPMHooks.source.clif.clearcart(fd); } if( HPMHooks.count.HP_clif_clearcart_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearcart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearcart_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -9764,11 +9789,11 @@ void HP_clif_clearcart(int fd) { void HP_clif_item_identify_list(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_identify_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identify_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_identify_list_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9790,11 +9815,11 @@ void HP_clif_item_identify_list(struct map_session_data *sd) { void HP_clif_item_identified(struct map_session_data *sd, int idx, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_identified_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *idx, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identified_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_identified_pre[hIndex].func; - preHookFunc(sd, &idx, &flag); + preHookFunc(&sd, &idx, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9805,10 +9830,10 @@ void HP_clif_item_identified(struct map_session_data *sd, int idx, int flag) { HPMHooks.source.clif.item_identified(sd, idx, flag); } if( HPMHooks.count.HP_clif_item_identified_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int idx, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identified_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_identified_post[hIndex].func; - postHookFunc(sd, &idx, &flag); + postHookFunc(sd, idx, flag); } } return; @@ -9816,11 +9841,11 @@ void HP_clif_item_identified(struct map_session_data *sd, int idx, int flag) { void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_data *dstsd, int lv) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_repair_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int *lv); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **dstsd, int *lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repair_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_repair_list_pre[hIndex].func; - preHookFunc(sd, dstsd, &lv); + preHookFunc(&sd, &dstsd, &lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9831,10 +9856,10 @@ void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_da HPMHooks.source.clif.item_repair_list(sd, dstsd, lv); } if( HPMHooks.count.HP_clif_item_repair_list_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int *lv); + void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repair_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_repair_list_post[hIndex].func; - postHookFunc(sd, dstsd, &lv); + postHookFunc(sd, dstsd, lv); } } return; @@ -9842,11 +9867,11 @@ void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_da void HP_clif_item_repaireffect(struct map_session_data *sd, int idx, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_repaireffect_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *idx, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repaireffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_repaireffect_pre[hIndex].func; - preHookFunc(sd, &idx, &flag); + preHookFunc(&sd, &idx, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9857,10 +9882,10 @@ void HP_clif_item_repaireffect(struct map_session_data *sd, int idx, int flag) { HPMHooks.source.clif.item_repaireffect(sd, idx, flag); } if( HPMHooks.count.HP_clif_item_repaireffect_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int idx, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repaireffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_repaireffect_post[hIndex].func; - postHookFunc(sd, &idx, &flag); + postHookFunc(sd, idx, flag); } } return; @@ -9868,11 +9893,11 @@ void HP_clif_item_repaireffect(struct map_session_data *sd, int idx, int flag) { void HP_clif_item_damaged(struct map_session_data *sd, unsigned short position) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_damaged_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *position); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *position); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_damaged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_damaged_pre[hIndex].func; - preHookFunc(sd, &position); + preHookFunc(&sd, &position); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9883,10 +9908,10 @@ void HP_clif_item_damaged(struct map_session_data *sd, unsigned short position) HPMHooks.source.clif.item_damaged(sd, position); } if( HPMHooks.count.HP_clif_item_damaged_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *position); + void (*postHookFunc) (struct map_session_data *sd, unsigned short position); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_damaged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_damaged_post[hIndex].func; - postHookFunc(sd, &position); + postHookFunc(sd, position); } } return; @@ -9894,11 +9919,11 @@ void HP_clif_item_damaged(struct map_session_data *sd, unsigned short position) void HP_clif_item_refine_list(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_refine_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_refine_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_refine_list_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9920,11 +9945,11 @@ void HP_clif_item_refine_list(struct map_session_data *sd) { void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_clif_item_skill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_skill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_item_skill_pre[hIndex].func; - preHookFunc(sd, &skill_id, &skill_lv); + preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9935,10 +9960,10 @@ void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 ski HPMHooks.source.clif.item_skill(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_clif_item_skill_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_skill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_item_skill_post[hIndex].func; - postHookFunc(sd, &skill_id, &skill_lv); + postHookFunc(sd, skill_id, skill_lv); } } return; @@ -9946,11 +9971,11 @@ void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 ski void HP_clif_mvp_item(struct map_session_data *sd, int nameid) { int hIndex = 0; if( HPMHooks.count.HP_clif_mvp_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *nameid); + void (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mvp_item_pre[hIndex].func; - preHookFunc(sd, &nameid); + preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9961,10 +9986,10 @@ void HP_clif_mvp_item(struct map_session_data *sd, int nameid) { HPMHooks.source.clif.mvp_item(sd, nameid); } if( HPMHooks.count.HP_clif_mvp_item_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *nameid); + void (*postHookFunc) (struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mvp_item_post[hIndex].func; - postHookFunc(sd, &nameid); + postHookFunc(sd, nameid); } } return; @@ -9972,11 +9997,11 @@ void HP_clif_mvp_item(struct map_session_data *sd, int nameid) { void HP_clif_mvp_exp(struct map_session_data *sd, unsigned int exp) { int hIndex = 0; if( HPMHooks.count.HP_clif_mvp_exp_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *exp); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *exp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_exp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mvp_exp_pre[hIndex].func; - preHookFunc(sd, &exp); + preHookFunc(&sd, &exp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -9987,10 +10012,10 @@ void HP_clif_mvp_exp(struct map_session_data *sd, unsigned int exp) { HPMHooks.source.clif.mvp_exp(sd, exp); } if( HPMHooks.count.HP_clif_mvp_exp_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *exp); + void (*postHookFunc) (struct map_session_data *sd, unsigned int exp); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_exp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mvp_exp_post[hIndex].func; - postHookFunc(sd, &exp); + postHookFunc(sd, exp); } } return; @@ -9998,11 +10023,11 @@ void HP_clif_mvp_exp(struct map_session_data *sd, unsigned int exp) { void HP_clif_mvp_noitem(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_mvp_noitem_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_noitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mvp_noitem_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10024,11 +10049,11 @@ void HP_clif_mvp_noitem(struct map_session_data *sd) { void HP_clif_changed_dir(struct block_list *bl, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_changed_dir_pre ) { - void (*preHookFunc) (struct block_list *bl, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changed_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changed_dir_pre[hIndex].func; - preHookFunc(bl, &target); + preHookFunc(&bl, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10039,10 +10064,10 @@ void HP_clif_changed_dir(struct block_list *bl, enum send_target target) { HPMHooks.source.clif.changed_dir(bl, target); } if( HPMHooks.count.HP_clif_changed_dir_post ) { - void (*postHookFunc) (struct block_list *bl, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changed_dir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changed_dir_post[hIndex].func; - postHookFunc(bl, &target); + postHookFunc(bl, target); } } return; @@ -10050,11 +10075,11 @@ void HP_clif_changed_dir(struct block_list *bl, enum send_target target) { void HP_clif_charnameack(int fd, struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_charnameack_pre ) { - void (*preHookFunc) (int *fd, struct block_list *bl); + void (*preHookFunc) (int *fd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_charnameack_pre[hIndex].func; - preHookFunc(&fd, bl); + preHookFunc(&fd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10065,10 +10090,10 @@ void HP_clif_charnameack(int fd, struct block_list *bl) { HPMHooks.source.clif.charnameack(fd, bl); } if( HPMHooks.count.HP_clif_charnameack_post ) { - void (*postHookFunc) (int *fd, struct block_list *bl); + void (*postHookFunc) (int fd, struct block_list *bl); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_charnameack_post[hIndex].func; - postHookFunc(&fd, bl); + postHookFunc(fd, bl); } } return; @@ -10076,11 +10101,11 @@ void HP_clif_charnameack(int fd, struct block_list *bl) { void HP_clif_monster_hp_bar(struct mob_data *md, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_monster_hp_bar_pre ) { - void (*preHookFunc) (struct mob_data *md, struct map_session_data *sd); + void (*preHookFunc) (struct mob_data **md, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_monster_hp_bar_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_monster_hp_bar_pre[hIndex].func; - preHookFunc(md, sd); + preHookFunc(&md, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10103,11 +10128,11 @@ int HP_clif_hpmeter(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_hpmeter_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_hpmeter_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10144,10 +10169,10 @@ void HP_clif_hpmeter_single(int fd, int id, unsigned int hp, unsigned int maxhp) HPMHooks.source.clif.hpmeter_single(fd, id, hp, maxhp); } if( HPMHooks.count.HP_clif_hpmeter_single_post ) { - void (*postHookFunc) (int *fd, int *id, unsigned int *hp, unsigned int *maxhp); + void (*postHookFunc) (int fd, int id, unsigned int hp, unsigned int maxhp); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_hpmeter_single_post[hIndex].func; - postHookFunc(&fd, &id, &hp, &maxhp); + postHookFunc(fd, id, hp, maxhp); } } return; @@ -10156,12 +10181,12 @@ int HP_clif_hpmeter_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_hpmeter_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_hpmeter_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -10203,10 +10228,10 @@ void HP_clif_upgrademessage(int fd, int result, int item_id) { HPMHooks.source.clif.upgrademessage(fd, result, item_id); } if( HPMHooks.count.HP_clif_upgrademessage_post ) { - void (*postHookFunc) (int *fd, int *result, int *item_id); + void (*postHookFunc) (int fd, int result, int item_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_upgrademessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_upgrademessage_post[hIndex].func; - postHookFunc(&fd, &result, &item_id); + postHookFunc(fd, result, item_id); } } return; @@ -10214,11 +10239,11 @@ void HP_clif_upgrademessage(int fd, int result, int item_id) { void HP_clif_get_weapon_view(struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand) { int hIndex = 0; if( HPMHooks.count.HP_clif_get_weapon_view_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand); + void (*preHookFunc) (struct map_session_data **sd, unsigned short **rhand, unsigned short **lhand); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_weapon_view_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_get_weapon_view_pre[hIndex].func; - preHookFunc(sd, rhand, lhand); + preHookFunc(&sd, &rhand, &lhand); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10240,11 +10265,11 @@ void HP_clif_get_weapon_view(struct map_session_data *sd, unsigned short *rhand, void HP_clif_gospel_info(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_gospel_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_gospel_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_gospel_info_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10255,10 +10280,10 @@ void HP_clif_gospel_info(struct map_session_data *sd, int type) { HPMHooks.source.clif.gospel_info(sd, type); } if( HPMHooks.count.HP_clif_gospel_info_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_gospel_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_gospel_info_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -10266,11 +10291,11 @@ void HP_clif_gospel_info(struct map_session_data *sd, int type) { void HP_clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_clif_feel_req_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv); + void (*preHookFunc) (int *fd, struct map_session_data **sd, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_req_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_feel_req_pre[hIndex].func; - preHookFunc(&fd, sd, &skill_lv); + preHookFunc(&fd, &sd, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10281,10 +10306,10 @@ void HP_clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv) { HPMHooks.source.clif.feel_req(fd, sd, skill_lv); } if( HPMHooks.count.HP_clif_feel_req_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv); + void (*postHookFunc) (int fd, struct map_session_data *sd, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_feel_req_post[hIndex].func; - postHookFunc(&fd, sd, &skill_lv); + postHookFunc(fd, sd, skill_lv); } } return; @@ -10292,11 +10317,11 @@ void HP_clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv) { void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result) { int hIndex = 0; if( HPMHooks.count.HP_clif_starskill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *mapname, int *monster_id, unsigned char *star, unsigned char *result); + void (*preHookFunc) (struct map_session_data **sd, const char **mapname, int *monster_id, unsigned char *star, unsigned char *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_starskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_starskill_pre[hIndex].func; - preHookFunc(sd, mapname, &monster_id, &star, &result); + preHookFunc(&sd, &mapname, &monster_id, &star, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10307,10 +10332,10 @@ void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int mon HPMHooks.source.clif.starskill(sd, mapname, monster_id, star, result); } if( HPMHooks.count.HP_clif_starskill_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *mapname, int *monster_id, unsigned char *star, unsigned char *result); + void (*postHookFunc) (struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_starskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_starskill_post[hIndex].func; - postHookFunc(sd, mapname, &monster_id, &star, &result); + postHookFunc(sd, mapname, monster_id, star, result); } } return; @@ -10318,11 +10343,11 @@ void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int mon void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, unsigned char type) { int hIndex = 0; if( HPMHooks.count.HP_clif_feel_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *feel_level, unsigned char *type); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *feel_level, unsigned char *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_feel_info_pre[hIndex].func; - preHookFunc(sd, &feel_level, &type); + preHookFunc(&sd, &feel_level, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10333,10 +10358,10 @@ void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, un HPMHooks.source.clif.feel_info(sd, feel_level, type); } if( HPMHooks.count.HP_clif_feel_info_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *feel_level, unsigned char *type); + void (*postHookFunc) (struct map_session_data *sd, unsigned char feel_level, unsigned char type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_feel_info_post[hIndex].func; - postHookFunc(sd, &feel_level, &type); + postHookFunc(sd, feel_level, type); } } return; @@ -10344,11 +10369,11 @@ void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, un void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type) { int hIndex = 0; if( HPMHooks.count.HP_clif_hate_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *hate_level, int *class_, unsigned char *type); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *hate_level, int *class_, unsigned char *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hate_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_hate_info_pre[hIndex].func; - preHookFunc(sd, &hate_level, &class_, &type); + preHookFunc(&sd, &hate_level, &class_, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10359,10 +10384,10 @@ void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, in HPMHooks.source.clif.hate_info(sd, hate_level, class_, type); } if( HPMHooks.count.HP_clif_hate_info_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *hate_level, int *class_, unsigned char *type); + void (*postHookFunc) (struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hate_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_hate_info_post[hIndex].func; - postHookFunc(sd, &hate_level, &class_, &type); + postHookFunc(sd, hate_level, class_, type); } } return; @@ -10370,11 +10395,11 @@ void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, in void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char progress) { int hIndex = 0; if( HPMHooks.count.HP_clif_mission_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *mob_id, unsigned char *progress); + void (*preHookFunc) (struct map_session_data **sd, int *mob_id, unsigned char *progress); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mission_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mission_info_pre[hIndex].func; - preHookFunc(sd, &mob_id, &progress); + preHookFunc(&sd, &mob_id, &progress); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10385,10 +10410,10 @@ void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char HPMHooks.source.clif.mission_info(sd, mob_id, progress); } if( HPMHooks.count.HP_clif_mission_info_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *mob_id, unsigned char *progress); + void (*postHookFunc) (struct map_session_data *sd, int mob_id, unsigned char progress); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mission_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mission_info_post[hIndex].func; - postHookFunc(sd, &mob_id, &progress); + postHookFunc(sd, mob_id, progress); } } return; @@ -10396,11 +10421,11 @@ void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char void HP_clif_feel_hate_reset(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_feel_hate_reset_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_hate_reset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_feel_hate_reset_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10422,11 +10447,11 @@ void HP_clif_feel_hate_reset(struct map_session_data *sd) { void HP_clif_partytickack(struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_partytickack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_partytickack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10437,10 +10462,10 @@ void HP_clif_partytickack(struct map_session_data *sd, bool flag) { HPMHooks.source.clif.partytickack(sd, flag); } if( HPMHooks.count.HP_clif_partytickack_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_partytickack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -10448,11 +10473,11 @@ void HP_clif_partytickack(struct map_session_data *sd, bool flag) { void HP_clif_equiptickack(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_equiptickack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_equiptickack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10463,10 +10488,10 @@ void HP_clif_equiptickack(struct map_session_data *sd, int flag) { HPMHooks.source.clif.equiptickack(sd, flag); } if( HPMHooks.count.HP_clif_equiptickack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_equiptickack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -10474,11 +10499,11 @@ void HP_clif_equiptickack(struct map_session_data *sd, int flag) { void HP_clif_viewequip_ack(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; if( HPMHooks.count.HP_clif_viewequip_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_viewequip_ack_pre[hIndex].func; - preHookFunc(sd, tsd); + preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10500,11 +10525,11 @@ void HP_clif_viewequip_ack(struct map_session_data *sd, struct map_session_data void HP_clif_equpcheckbox(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_equpcheckbox_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equpcheckbox_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_equpcheckbox_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10526,11 +10551,11 @@ void HP_clif_equpcheckbox(struct map_session_data *sd) { void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type, bool is_quest) { int hIndex = 0; if( HPMHooks.count.HP_clif_displayexp_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *exp, char *type, bool *is_quest); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *exp, char *type, bool *is_quest); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_displayexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_displayexp_pre[hIndex].func; - preHookFunc(sd, &exp, &type, &is_quest); + preHookFunc(&sd, &exp, &type, &is_quest); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10541,10 +10566,10 @@ void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type HPMHooks.source.clif.displayexp(sd, exp, type, is_quest); } if( HPMHooks.count.HP_clif_displayexp_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *exp, char *type, bool *is_quest); + void (*postHookFunc) (struct map_session_data *sd, unsigned int exp, char type, bool is_quest); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_displayexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_displayexp_post[hIndex].func; - postHookFunc(sd, &exp, &type, &is_quest); + postHookFunc(sd, exp, type, is_quest); } } return; @@ -10552,11 +10577,11 @@ void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type void HP_clif_font(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_font_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_font_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_font_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10578,11 +10603,11 @@ void HP_clif_font(struct map_session_data *sd) { void HP_clif_progressbar(struct map_session_data *sd, unsigned int color, unsigned int second) { int hIndex = 0; if( HPMHooks.count.HP_clif_progressbar_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *color, unsigned int *second); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *color, unsigned int *second); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_progressbar_pre[hIndex].func; - preHookFunc(sd, &color, &second); + preHookFunc(&sd, &color, &second); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10593,10 +10618,10 @@ void HP_clif_progressbar(struct map_session_data *sd, unsigned int color, unsign HPMHooks.source.clif.progressbar(sd, color, second); } if( HPMHooks.count.HP_clif_progressbar_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *color, unsigned int *second); + void (*postHookFunc) (struct map_session_data *sd, unsigned int color, unsigned int second); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_progressbar_post[hIndex].func; - postHookFunc(sd, &color, &second); + postHookFunc(sd, color, second); } } return; @@ -10604,11 +10629,11 @@ void HP_clif_progressbar(struct map_session_data *sd, unsigned int color, unsign void HP_clif_progressbar_abort(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_progressbar_abort_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_abort_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_progressbar_abort_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10630,11 +10655,11 @@ void HP_clif_progressbar_abort(struct map_session_data *sd) { void HP_clif_showdigit(struct map_session_data *sd, unsigned char type, int value) { int hIndex = 0; if( HPMHooks.count.HP_clif_showdigit_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *type, int *value); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *type, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_showdigit_pre[hIndex].func; - preHookFunc(sd, &type, &value); + preHookFunc(&sd, &type, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10645,10 +10670,10 @@ void HP_clif_showdigit(struct map_session_data *sd, unsigned char type, int valu HPMHooks.source.clif.showdigit(sd, type, value); } if( HPMHooks.count.HP_clif_showdigit_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *type, int *value); + void (*postHookFunc) (struct map_session_data *sd, unsigned char type, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_showdigit_post[hIndex].func; - postHookFunc(sd, &type, &value); + postHookFunc(sd, type, value); } } return; @@ -10657,11 +10682,11 @@ int HP_clif_elementalconverter_list(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_elementalconverter_list_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elementalconverter_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_elementalconverter_list_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10684,11 +10709,11 @@ int HP_clif_spellbook_list(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_spellbook_list_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spellbook_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spellbook_list_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10711,11 +10736,11 @@ int HP_clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_magicdecoy_list_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv, short *x, short *y); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv, short *x, short *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_magicdecoy_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_magicdecoy_list_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_lv, &x, &y); + retVal___ = preHookFunc(&sd, &skill_lv, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10726,10 +10751,10 @@ int HP_clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short retVal___ = HPMHooks.source.clif.magicdecoy_list(sd, skill_lv, x, y); } if( HPMHooks.count.HP_clif_magicdecoy_list_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv, short *x, short *y); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv, short x, short y); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_magicdecoy_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_magicdecoy_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_lv, &x, &y); + retVal___ = postHookFunc(retVal___, sd, skill_lv, x, y); } } return retVal___; @@ -10738,11 +10763,11 @@ int HP_clif_poison_list(struct map_session_data *sd, uint16 skill_lv) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_poison_list_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_poison_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_poison_list_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10753,10 +10778,10 @@ int HP_clif_poison_list(struct map_session_data *sd, uint16 skill_lv) { retVal___ = HPMHooks.source.clif.poison_list(sd, skill_lv); } if( HPMHooks.count.HP_clif_poison_list_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_poison_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_poison_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_lv); } } return retVal___; @@ -10765,11 +10790,11 @@ int HP_clif_autoshadowspell_list(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_autoshadowspell_list_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autoshadowspell_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_autoshadowspell_list_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10792,11 +10817,11 @@ int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, u int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_skill_itemlistwindow_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_itemlistwindow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_itemlistwindow_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10807,10 +10832,10 @@ int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, u retVal___ = HPMHooks.source.clif.skill_itemlistwindow(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_clif_skill_itemlistwindow_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_itemlistwindow_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_itemlistwindow_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv); } } return retVal___; @@ -10818,11 +10843,11 @@ int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, u void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3) { int hIndex = 0; if( HPMHooks.count.HP_clif_sc_load_pre ) { - void (*preHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3); + void (*preHookFunc) (struct block_list **bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sc_load_pre[hIndex].func; - preHookFunc(bl, &tid, &target, &type, &val1, &val2, &val3); + preHookFunc(&bl, &tid, &target, &type, &val1, &val2, &val3); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10833,10 +10858,10 @@ void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, in HPMHooks.source.clif.sc_load(bl, tid, target, type, val1, val2, val3); } if( HPMHooks.count.HP_clif_sc_load_post ) { - void (*postHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3); + void (*postHookFunc) (struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_sc_load_post[hIndex].func; - postHookFunc(bl, &tid, &target, &type, &val1, &val2, &val3); + postHookFunc(bl, tid, target, type, val1, val2, val3); } } return; @@ -10844,11 +10869,11 @@ void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, in void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_sc_end_pre ) { - void (*preHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type); + void (*preHookFunc) (struct block_list **bl, int *tid, enum send_target *target, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_end_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sc_end_pre[hIndex].func; - preHookFunc(bl, &tid, &target, &type); + preHookFunc(&bl, &tid, &target, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10859,10 +10884,10 @@ void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int HPMHooks.source.clif.sc_end(bl, tid, target, type); } if( HPMHooks.count.HP_clif_sc_end_post ) { - void (*postHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type); + void (*postHookFunc) (struct block_list *bl, int tid, enum send_target target, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_sc_end_post[hIndex].func; - postHookFunc(bl, &tid, &target, &type); + postHookFunc(bl, tid, target, type); } } return; @@ -10870,11 +10895,11 @@ void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int void HP_clif_initialstatus(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_initialstatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_initialstatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_initialstatus_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10896,11 +10921,11 @@ void HP_clif_initialstatus(struct map_session_data *sd) { void HP_clif_cooldown_list(int fd, struct skill_cd *cd) { int hIndex = 0; if( HPMHooks.count.HP_clif_cooldown_list_pre ) { - void (*preHookFunc) (int *fd, struct skill_cd *cd); + void (*preHookFunc) (int *fd, struct skill_cd **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooldown_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cooldown_list_pre[hIndex].func; - preHookFunc(&fd, cd); + preHookFunc(&fd, &cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10911,10 +10936,10 @@ void HP_clif_cooldown_list(int fd, struct skill_cd *cd) { HPMHooks.source.clif.cooldown_list(fd, cd); } if( HPMHooks.count.HP_clif_cooldown_list_post ) { - void (*postHookFunc) (int *fd, struct skill_cd *cd); + void (*postHookFunc) (int fd, struct skill_cd *cd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooldown_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cooldown_list_post[hIndex].func; - postHookFunc(&fd, cd); + postHookFunc(fd, cd); } } return; @@ -10922,11 +10947,11 @@ void HP_clif_cooldown_list(int fd, struct skill_cd *cd) { void HP_clif_updatestatus(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_updatestatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_updatestatus_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10937,10 +10962,10 @@ void HP_clif_updatestatus(struct map_session_data *sd, int type) { HPMHooks.source.clif.updatestatus(sd, type); } if( HPMHooks.count.HP_clif_updatestatus_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_updatestatus_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -10948,11 +10973,11 @@ void HP_clif_updatestatus(struct map_session_data *sd, int type) { void HP_clif_changestatus(struct map_session_data *sd, int type, int val) { int hIndex = 0; if( HPMHooks.count.HP_clif_changestatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + void (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changestatus_pre[hIndex].func; - preHookFunc(sd, &type, &val); + preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10963,10 +10988,10 @@ void HP_clif_changestatus(struct map_session_data *sd, int type, int val) { HPMHooks.source.clif.changestatus(sd, type, val); } if( HPMHooks.count.HP_clif_changestatus_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type, int *val); + void (*postHookFunc) (struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_changestatus_post[hIndex].func; - postHookFunc(sd, &type, &val); + postHookFunc(sd, type, val); } } return; @@ -10974,11 +10999,11 @@ void HP_clif_changestatus(struct map_session_data *sd, int type, int val) { void HP_clif_statusupack(struct map_session_data *sd, int type, int ok, int val) { int hIndex = 0; if( HPMHooks.count.HP_clif_statusupack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type, int *ok, int *val); + void (*preHookFunc) (struct map_session_data **sd, int *type, int *ok, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_statusupack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_statusupack_pre[hIndex].func; - preHookFunc(sd, &type, &ok, &val); + preHookFunc(&sd, &type, &ok, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -10989,10 +11014,10 @@ void HP_clif_statusupack(struct map_session_data *sd, int type, int ok, int val) HPMHooks.source.clif.statusupack(sd, type, ok, val); } if( HPMHooks.count.HP_clif_statusupack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type, int *ok, int *val); + void (*postHookFunc) (struct map_session_data *sd, int type, int ok, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_statusupack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_statusupack_post[hIndex].func; - postHookFunc(sd, &type, &ok, &val); + postHookFunc(sd, type, ok, val); } } return; @@ -11000,11 +11025,11 @@ void HP_clif_statusupack(struct map_session_data *sd, int type, int ok, int val) void HP_clif_movetoattack(struct map_session_data *sd, struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_movetoattack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_movetoattack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_movetoattack_pre[hIndex].func; - preHookFunc(sd, bl); + preHookFunc(&sd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11026,11 +11051,11 @@ void HP_clif_movetoattack(struct map_session_data *sd, struct block_list *bl) { void HP_clif_solved_charname(int fd, int charid, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_solved_charname_pre ) { - void (*preHookFunc) (int *fd, int *charid, const char *name); + void (*preHookFunc) (int *fd, int *charid, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_solved_charname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_solved_charname_pre[hIndex].func; - preHookFunc(&fd, &charid, name); + preHookFunc(&fd, &charid, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11041,10 +11066,10 @@ void HP_clif_solved_charname(int fd, int charid, const char *name) { HPMHooks.source.clif.solved_charname(fd, charid, name); } if( HPMHooks.count.HP_clif_solved_charname_post ) { - void (*postHookFunc) (int *fd, int *charid, const char *name); + void (*postHookFunc) (int fd, int charid, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_solved_charname_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_solved_charname_post[hIndex].func; - postHookFunc(&fd, &charid, name); + postHookFunc(fd, charid, name); } } return; @@ -11052,11 +11077,11 @@ void HP_clif_solved_charname(int fd, int charid, const char *name) { void HP_clif_charnameupdate(struct map_session_data *ssd) { int hIndex = 0; if( HPMHooks.count.HP_clif_charnameupdate_pre ) { - void (*preHookFunc) (struct map_session_data *ssd); + void (*preHookFunc) (struct map_session_data **ssd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameupdate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_charnameupdate_pre[hIndex].func; - preHookFunc(ssd); + preHookFunc(&ssd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11094,10 +11119,10 @@ int HP_clif_delayquit(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.clif.delayquit(tid, tick, id, data); } if( HPMHooks.count.HP_clif_delayquit_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delayquit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_delayquit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -11105,11 +11130,11 @@ int HP_clif_delayquit(int tid, int64 tick, int id, intptr_t data) { void HP_clif_getareachar_pc(struct map_session_data *sd, struct map_session_data *dstsd) { int hIndex = 0; if( HPMHooks.count.HP_clif_getareachar_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **dstsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_getareachar_pc_pre[hIndex].func; - preHookFunc(sd, dstsd); + preHookFunc(&sd, &dstsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11131,11 +11156,11 @@ void HP_clif_getareachar_pc(struct map_session_data *sd, struct map_session_data void HP_clif_disconnect_ack(struct map_session_data *sd, short result) { int hIndex = 0; if( HPMHooks.count.HP_clif_disconnect_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *result); + void (*preHookFunc) (struct map_session_data **sd, short *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disconnect_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_disconnect_ack_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11146,10 +11171,10 @@ void HP_clif_disconnect_ack(struct map_session_data *sd, short result) { HPMHooks.source.clif.disconnect_ack(sd, result); } if( HPMHooks.count.HP_clif_disconnect_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *result); + void (*postHookFunc) (struct map_session_data *sd, short result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disconnect_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_disconnect_ack_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -11157,11 +11182,11 @@ void HP_clif_disconnect_ack(struct map_session_data *sd, short result) { void HP_clif_PVPInfo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PVPInfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PVPInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PVPInfo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11183,11 +11208,11 @@ void HP_clif_PVPInfo(struct map_session_data *sd) { void HP_clif_blacksmith(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_blacksmith_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blacksmith_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_blacksmith_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11209,11 +11234,11 @@ void HP_clif_blacksmith(struct map_session_data *sd) { void HP_clif_alchemist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_alchemist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_alchemist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_alchemist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11235,11 +11260,11 @@ void HP_clif_alchemist(struct map_session_data *sd) { void HP_clif_taekwon(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_taekwon_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_taekwon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_taekwon_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11261,11 +11286,11 @@ void HP_clif_taekwon(struct map_session_data *sd) { void HP_clif_ranking_pk(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_ranking_pk_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranking_pk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_ranking_pk_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11287,11 +11312,11 @@ void HP_clif_ranking_pk(struct map_session_data *sd) { void HP_clif_quitsave(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_quitsave_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quitsave_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11302,10 +11327,10 @@ void HP_clif_quitsave(int fd, struct map_session_data *sd) { HPMHooks.source.clif.quitsave(fd, sd); } if( HPMHooks.count.HP_clif_quitsave_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_quitsave_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -11313,11 +11338,11 @@ void HP_clif_quitsave(int fd, struct map_session_data *sd) { void HP_clif_misceffect(struct block_list *bl, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_misceffect_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type); + void (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_misceffect_pre[hIndex].func; - preHookFunc(bl, &type); + preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11328,10 +11353,10 @@ void HP_clif_misceffect(struct block_list *bl, int type) { HPMHooks.source.clif.misceffect(bl, type); } if( HPMHooks.count.HP_clif_misceffect_post ) { - void (*postHookFunc) (struct block_list *bl, int *type); + void (*postHookFunc) (struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_misceffect_post[hIndex].func; - postHookFunc(bl, &type); + postHookFunc(bl, type); } } return; @@ -11339,11 +11364,11 @@ void HP_clif_misceffect(struct block_list *bl, int type) { void HP_clif_changeoption(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_changeoption_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changeoption_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11365,11 +11390,11 @@ void HP_clif_changeoption(struct block_list *bl) { void HP_clif_changeoption2(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_changeoption2_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changeoption2_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11391,11 +11416,11 @@ void HP_clif_changeoption2(struct block_list *bl) { void HP_clif_emotion(struct block_list *bl, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_emotion_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type); + void (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_emotion_pre[hIndex].func; - preHookFunc(bl, &type); + preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11406,10 +11431,10 @@ void HP_clif_emotion(struct block_list *bl, int type) { HPMHooks.source.clif.emotion(bl, type); } if( HPMHooks.count.HP_clif_emotion_post ) { - void (*postHookFunc) (struct block_list *bl, int *type); + void (*postHookFunc) (struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_emotion_post[hIndex].func; - postHookFunc(bl, &type); + postHookFunc(bl, type); } } return; @@ -11417,11 +11442,11 @@ void HP_clif_emotion(struct block_list *bl, int type) { void HP_clif_talkiebox(struct block_list *bl, const char *talkie) { int hIndex = 0; if( HPMHooks.count.HP_clif_talkiebox_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *talkie); + void (*preHookFunc) (struct block_list **bl, const char **talkie); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_talkiebox_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_talkiebox_pre[hIndex].func; - preHookFunc(bl, talkie); + preHookFunc(&bl, &talkie); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11443,11 +11468,11 @@ void HP_clif_talkiebox(struct block_list *bl, const char *talkie) { void HP_clif_wedding_effect(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_wedding_effect_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wedding_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_wedding_effect_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11469,11 +11494,11 @@ void HP_clif_wedding_effect(struct block_list *bl) { void HP_clif_divorced(struct map_session_data *sd, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_divorced_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name); + void (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_divorced_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_divorced_pre[hIndex].func; - preHookFunc(sd, name); + preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11495,11 +11520,11 @@ void HP_clif_divorced(struct map_session_data *sd, const char *name) { void HP_clif_callpartner(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_callpartner_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_callpartner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_callpartner_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11522,11 +11547,11 @@ int HP_clif_skill_damage(struct block_list *src, struct block_list *dst, int64 t int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_skill_damage_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *dst, int64 *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type); + int (*preHookFunc) (struct block_list **src, struct block_list **dst, int64 *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, dst, &tick, &sdelay, &ddelay, &damage, &div, &skill_id, &skill_lv, &type); + retVal___ = preHookFunc(&src, &dst, &tick, &sdelay, &ddelay, &damage, &div, &skill_id, &skill_lv, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11537,10 +11562,10 @@ int HP_clif_skill_damage(struct block_list *src, struct block_list *dst, int64 t retVal___ = HPMHooks.source.clif.skill_damage(src, dst, tick, sdelay, ddelay, damage, div, skill_id, skill_lv, type); } if( HPMHooks.count.HP_clif_skill_damage_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int64 *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int64 tick, int sdelay, int ddelay, int64 damage, int div, uint16 skill_id, uint16 skill_lv, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, dst, &tick, &sdelay, &ddelay, &damage, &div, &skill_id, &skill_lv, &type); + retVal___ = postHookFunc(retVal___, src, dst, tick, sdelay, ddelay, damage, div, skill_id, skill_lv, type); } } return retVal___; @@ -11549,11 +11574,11 @@ int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint1 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_skill_nodamage_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *dst, uint16 *skill_id, int *heal, int *fail); + int (*preHookFunc) (struct block_list **src, struct block_list **dst, uint16 *skill_id, int *heal, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_nodamage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_nodamage_pre[hIndex].func; - retVal___ = preHookFunc(src, dst, &skill_id, &heal, &fail); + retVal___ = preHookFunc(&src, &dst, &skill_id, &heal, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11564,10 +11589,10 @@ int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint1 retVal___ = HPMHooks.source.clif.skill_nodamage(src, dst, skill_id, heal, fail); } if( HPMHooks.count.HP_clif_skill_nodamage_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, uint16 *skill_id, int *heal, int *fail); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, uint16 skill_id, int heal, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_nodamage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_nodamage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, dst, &skill_id, &heal, &fail); + retVal___ = postHookFunc(retVal___, src, dst, skill_id, heal, fail); } } return retVal___; @@ -11575,11 +11600,11 @@ int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint1 void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, int x, int y, int64 tick) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_poseffect_pre ) { - void (*preHookFunc) (struct block_list *src, uint16 *skill_id, int *val, int *x, int *y, int64 *tick); + void (*preHookFunc) (struct block_list **src, uint16 *skill_id, int *val, int *x, int *y, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_poseffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_poseffect_pre[hIndex].func; - preHookFunc(src, &skill_id, &val, &x, &y, &tick); + preHookFunc(&src, &skill_id, &val, &x, &y, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11590,10 +11615,10 @@ void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, i HPMHooks.source.clif.skill_poseffect(src, skill_id, val, x, y, tick); } if( HPMHooks.count.HP_clif_skill_poseffect_post ) { - void (*postHookFunc) (struct block_list *src, uint16 *skill_id, int *val, int *x, int *y, int64 *tick); + void (*postHookFunc) (struct block_list *src, uint16 skill_id, int val, int x, int y, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_poseffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_poseffect_post[hIndex].func; - postHookFunc(src, &skill_id, &val, &x, &y, &tick); + postHookFunc(src, skill_id, val, x, y, tick); } } return; @@ -11601,11 +11626,11 @@ void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, i void HP_clif_skill_estimation(struct map_session_data *sd, struct block_list *dst) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_estimation_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *dst); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **dst); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_estimation_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_estimation_pre[hIndex].func; - preHookFunc(sd, dst); + preHookFunc(&sd, &dst); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11627,11 +11652,11 @@ void HP_clif_skill_estimation(struct map_session_data *sd, struct block_list *ds void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4) { int hIndex = 0; if( HPMHooks.count.HP_clif_skill_warppoint_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_warppoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skill_warppoint_pre[hIndex].func; - preHookFunc(sd, &skill_id, &skill_lv, &map1, &map2, &map3, &map4); + preHookFunc(&sd, &skill_id, &skill_lv, &map1, &map2, &map3, &map4); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11642,10 +11667,10 @@ void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint1 HPMHooks.source.clif.skill_warppoint(sd, skill_id, skill_lv, map1, map2, map3, map4); } if( HPMHooks.count.HP_clif_skill_warppoint_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_warppoint_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skill_warppoint_post[hIndex].func; - postHookFunc(sd, &skill_id, &skill_lv, &map1, &map2, &map3, &map4); + postHookFunc(sd, skill_id, skill_lv, map1, map2, map3, map4); } } return; @@ -11653,11 +11678,11 @@ void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint1 void HP_clif_skillcasting(struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, int property, int casttime) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillcasting_pre ) { - void (*preHookFunc) (struct block_list *bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime); + void (*preHookFunc) (struct block_list **bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcasting_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillcasting_pre[hIndex].func; - preHookFunc(bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &property, &casttime); + preHookFunc(&bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &property, &casttime); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11668,10 +11693,10 @@ void HP_clif_skillcasting(struct block_list *bl, int src_id, int dst_id, int dst HPMHooks.source.clif.skillcasting(bl, src_id, dst_id, dst_x, dst_y, skill_id, property, casttime); } if( HPMHooks.count.HP_clif_skillcasting_post ) { - void (*postHookFunc) (struct block_list *bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime); + void (*postHookFunc) (struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, int property, int casttime); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcasting_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skillcasting_post[hIndex].func; - postHookFunc(bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &property, &casttime); + postHookFunc(bl, src_id, dst_id, dst_x, dst_y, skill_id, property, casttime); } } return; @@ -11679,11 +11704,11 @@ void HP_clif_skillcasting(struct block_list *bl, int src_id, int dst_id, int dst void HP_clif_produce_effect(struct map_session_data *sd, int flag, int nameid) { int hIndex = 0; if( HPMHooks.count.HP_clif_produce_effect_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag, int *nameid); + void (*preHookFunc) (struct map_session_data **sd, int *flag, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_produce_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_produce_effect_pre[hIndex].func; - preHookFunc(sd, &flag, &nameid); + preHookFunc(&sd, &flag, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11694,10 +11719,10 @@ void HP_clif_produce_effect(struct map_session_data *sd, int flag, int nameid) { HPMHooks.source.clif.produce_effect(sd, flag, nameid); } if( HPMHooks.count.HP_clif_produce_effect_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag, int *nameid); + void (*postHookFunc) (struct map_session_data *sd, int flag, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_produce_effect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_produce_effect_post[hIndex].func; - postHookFunc(sd, &flag, &nameid); + postHookFunc(sd, flag, nameid); } } return; @@ -11705,11 +11730,11 @@ void HP_clif_produce_effect(struct map_session_data *sd, int flag, int nameid) { void HP_clif_devotion(struct block_list *src, struct map_session_data *tsd) { int hIndex = 0; if( HPMHooks.count.HP_clif_devotion_pre ) { - void (*preHookFunc) (struct block_list *src, struct map_session_data *tsd); + void (*preHookFunc) (struct block_list **src, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_devotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_devotion_pre[hIndex].func; - preHookFunc(src, tsd); + preHookFunc(&src, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11731,11 +11756,11 @@ void HP_clif_devotion(struct block_list *src, struct map_session_data *tsd) { void HP_clif_spiritball(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_spiritball_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spiritball_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11757,11 +11782,11 @@ void HP_clif_spiritball(struct block_list *bl) { void HP_clif_spiritball_single(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_spiritball_single_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spiritball_single_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11772,10 +11797,10 @@ void HP_clif_spiritball_single(int fd, struct map_session_data *sd) { HPMHooks.source.clif.spiritball_single(fd, sd); } if( HPMHooks.count.HP_clif_spiritball_single_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_spiritball_single_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -11783,11 +11808,11 @@ void HP_clif_spiritball_single(int fd, struct map_session_data *sd) { void HP_clif_bladestop(struct block_list *src, int dst_id, int active) { int hIndex = 0; if( HPMHooks.count.HP_clif_bladestop_pre ) { - void (*preHookFunc) (struct block_list *src, int *dst_id, int *active); + void (*preHookFunc) (struct block_list **src, int *dst_id, int *active); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bladestop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bladestop_pre[hIndex].func; - preHookFunc(src, &dst_id, &active); + preHookFunc(&src, &dst_id, &active); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11798,10 +11823,10 @@ void HP_clif_bladestop(struct block_list *src, int dst_id, int active) { HPMHooks.source.clif.bladestop(src, dst_id, active); } if( HPMHooks.count.HP_clif_bladestop_post ) { - void (*postHookFunc) (struct block_list *src, int *dst_id, int *active); + void (*postHookFunc) (struct block_list *src, int dst_id, int active); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bladestop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bladestop_post[hIndex].func; - postHookFunc(src, &dst_id, &active); + postHookFunc(src, dst_id, active); } } return; @@ -11809,11 +11834,11 @@ void HP_clif_bladestop(struct block_list *src, int dst_id, int active) { void HP_clif_mvp_effect(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_mvp_effect_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mvp_effect_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11850,10 +11875,10 @@ void HP_clif_heal(int fd, int type, int val) { HPMHooks.source.clif.heal(fd, type, val); } if( HPMHooks.count.HP_clif_heal_post ) { - void (*postHookFunc) (int *fd, int *type, int *val); + void (*postHookFunc) (int fd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_heal_post[hIndex].func; - postHookFunc(&fd, &type, &val); + postHookFunc(fd, type, val); } } return; @@ -11861,11 +11886,11 @@ void HP_clif_heal(int fd, int type, int val) { void HP_clif_resurrection(struct block_list *bl, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_resurrection_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type); + void (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_resurrection_pre[hIndex].func; - preHookFunc(bl, &type); + preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11876,10 +11901,10 @@ void HP_clif_resurrection(struct block_list *bl, int type) { HPMHooks.source.clif.resurrection(bl, type); } if( HPMHooks.count.HP_clif_resurrection_post ) { - void (*postHookFunc) (struct block_list *bl, int *type); + void (*postHookFunc) (struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_resurrection_post[hIndex].func; - postHookFunc(bl, &type); + postHookFunc(bl, type); } } return; @@ -11902,10 +11927,10 @@ void HP_clif_refine(int fd, int fail, int index, int val) { HPMHooks.source.clif.refine(fd, fail, index, val); } if( HPMHooks.count.HP_clif_refine_post ) { - void (*postHookFunc) (int *fd, int *fail, int *index, int *val); + void (*postHookFunc) (int fd, int fail, int index, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refine_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_refine_post[hIndex].func; - postHookFunc(&fd, &fail, &index, &val); + postHookFunc(fd, fail, index, val); } } return; @@ -11928,10 +11953,10 @@ void HP_clif_weather(int16 m) { HPMHooks.source.clif.weather(m); } if( HPMHooks.count.HP_clif_weather_post ) { - void (*postHookFunc) (int16 *m); + void (*postHookFunc) (int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_weather_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -11939,11 +11964,11 @@ void HP_clif_weather(int16 m) { void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_specialeffect_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, int *type, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_specialeffect_pre[hIndex].func; - preHookFunc(bl, &type, &target); + preHookFunc(&bl, &type, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11954,10 +11979,10 @@ void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target tar HPMHooks.source.clif.specialeffect(bl, type, target); } if( HPMHooks.count.HP_clif_specialeffect_post ) { - void (*postHookFunc) (struct block_list *bl, int *type, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, int type, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_specialeffect_post[hIndex].func; - postHookFunc(bl, &type, &target); + postHookFunc(bl, type, target); } } return; @@ -11965,11 +11990,11 @@ void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target tar void HP_clif_specialeffect_single(struct block_list *bl, int type, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_specialeffect_single_pre ) { - void (*preHookFunc) (struct block_list *bl, int *type, int *fd); + void (*preHookFunc) (struct block_list **bl, int *type, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_specialeffect_single_pre[hIndex].func; - preHookFunc(bl, &type, &fd); + preHookFunc(&bl, &type, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -11980,10 +12005,10 @@ void HP_clif_specialeffect_single(struct block_list *bl, int type, int fd) { HPMHooks.source.clif.specialeffect_single(bl, type, fd); } if( HPMHooks.count.HP_clif_specialeffect_single_post ) { - void (*postHookFunc) (struct block_list *bl, int *type, int *fd); + void (*postHookFunc) (struct block_list *bl, int type, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_specialeffect_single_post[hIndex].func; - postHookFunc(bl, &type, &fd); + postHookFunc(bl, type, fd); } } return; @@ -11991,11 +12016,11 @@ void HP_clif_specialeffect_single(struct block_list *bl, int type, int fd) { void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num, send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_specialeffect_value_pre ) { - void (*preHookFunc) (struct block_list *bl, int *effect_id, int *num, send_target *target); + void (*preHookFunc) (struct block_list **bl, int *effect_id, int *num, send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_specialeffect_value_pre[hIndex].func; - preHookFunc(bl, &effect_id, &num, &target); + preHookFunc(&bl, &effect_id, &num, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12006,10 +12031,10 @@ void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num, HPMHooks.source.clif.specialeffect_value(bl, effect_id, num, target); } if( HPMHooks.count.HP_clif_specialeffect_value_post ) { - void (*postHookFunc) (struct block_list *bl, int *effect_id, int *num, send_target *target); + void (*postHookFunc) (struct block_list *bl, int effect_id, int num, send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_value_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_specialeffect_value_post[hIndex].func; - postHookFunc(bl, &effect_id, &num, &target); + postHookFunc(bl, effect_id, num, target); } } return; @@ -12017,11 +12042,11 @@ void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num, void HP_clif_millenniumshield(struct block_list *bl, short shields) { int hIndex = 0; if( HPMHooks.count.HP_clif_millenniumshield_pre ) { - void (*preHookFunc) (struct block_list *bl, short *shields); + void (*preHookFunc) (struct block_list **bl, short *shields); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_millenniumshield_pre[hIndex].func; - preHookFunc(bl, &shields); + preHookFunc(&bl, &shields); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12032,10 +12057,10 @@ void HP_clif_millenniumshield(struct block_list *bl, short shields) { HPMHooks.source.clif.millenniumshield(bl, shields); } if( HPMHooks.count.HP_clif_millenniumshield_post ) { - void (*postHookFunc) (struct block_list *bl, short *shields); + void (*postHookFunc) (struct block_list *bl, short shields); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_millenniumshield_post[hIndex].func; - postHookFunc(bl, &shields); + postHookFunc(bl, shields); } } return; @@ -12043,11 +12068,11 @@ void HP_clif_millenniumshield(struct block_list *bl, short shields) { void HP_clif_spiritcharm(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_spiritcharm_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritcharm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_spiritcharm_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12069,11 +12094,11 @@ void HP_clif_spiritcharm(struct map_session_data *sd) { void HP_clif_charm_single(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_charm_single_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_charm_single_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12084,10 +12109,10 @@ void HP_clif_charm_single(int fd, struct map_session_data *sd) { HPMHooks.source.clif.charm_single(fd, sd); } if( HPMHooks.count.HP_clif_charm_single_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_charm_single_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -12095,11 +12120,11 @@ void HP_clif_charm_single(int fd, struct map_session_data *sd) { void HP_clif_snap(struct block_list *bl, short x, short y) { int hIndex = 0; if( HPMHooks.count.HP_clif_snap_pre ) { - void (*preHookFunc) (struct block_list *bl, short *x, short *y); + void (*preHookFunc) (struct block_list **bl, short *x, short *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_snap_pre[hIndex].func; - preHookFunc(bl, &x, &y); + preHookFunc(&bl, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12110,10 +12135,10 @@ void HP_clif_snap(struct block_list *bl, short x, short y) { HPMHooks.source.clif.snap(bl, x, y); } if( HPMHooks.count.HP_clif_snap_post ) { - void (*postHookFunc) (struct block_list *bl, short *x, short *y); + void (*postHookFunc) (struct block_list *bl, short x, short y); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_snap_post[hIndex].func; - postHookFunc(bl, &x, &y); + postHookFunc(bl, x, y); } } return; @@ -12121,11 +12146,11 @@ void HP_clif_snap(struct block_list *bl, short x, short y) { void HP_clif_weather_check(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_weather_check_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_weather_check_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12147,11 +12172,11 @@ void HP_clif_weather_check(struct map_session_data *sd) { void HP_clif_playBGM(struct map_session_data *sd, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_playBGM_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name); + void (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_playBGM_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_playBGM_pre[hIndex].func; - preHookFunc(sd, name); + preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12173,11 +12198,11 @@ void HP_clif_playBGM(struct map_session_data *sd, const char *name) { void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, const char *name, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_soundeffect_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int *type); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, const char **name, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_soundeffect_pre[hIndex].func; - preHookFunc(sd, bl, name, &type); + preHookFunc(&sd, &bl, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12188,10 +12213,10 @@ void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, con HPMHooks.source.clif.soundeffect(sd, bl, name, type); } if( HPMHooks.count.HP_clif_soundeffect_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int *type); + void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_soundeffect_post[hIndex].func; - postHookFunc(sd, bl, name, &type); + postHookFunc(sd, bl, name, type); } } return; @@ -12199,11 +12224,11 @@ void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, con void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, enum send_target coverage) { int hIndex = 0; if( HPMHooks.count.HP_clif_soundeffectall_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *name, int *type, enum send_target *coverage); + void (*preHookFunc) (struct block_list **bl, const char **name, int *type, enum send_target *coverage); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffectall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_soundeffectall_pre[hIndex].func; - preHookFunc(bl, name, &type, &coverage); + preHookFunc(&bl, &name, &type, &coverage); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12214,10 +12239,10 @@ void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, e HPMHooks.source.clif.soundeffectall(bl, name, type, coverage); } if( HPMHooks.count.HP_clif_soundeffectall_post ) { - void (*postHookFunc) (struct block_list *bl, const char *name, int *type, enum send_target *coverage); + void (*postHookFunc) (struct block_list *bl, const char *name, int type, enum send_target coverage); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffectall_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_soundeffectall_post[hIndex].func; - postHookFunc(bl, name, &type, &coverage); + postHookFunc(bl, name, type, coverage); } } return; @@ -12225,11 +12250,11 @@ void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, e void HP_clif_GlobalMessage(struct block_list *bl, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_clif_GlobalMessage_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *message); + void (*preHookFunc) (struct block_list **bl, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GlobalMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_GlobalMessage_pre[hIndex].func; - preHookFunc(bl, message); + preHookFunc(&bl, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12251,11 +12276,11 @@ void HP_clif_GlobalMessage(struct block_list *bl, const char *message) { void HP_clif_createchat(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_createchat_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_createchat_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12266,10 +12291,10 @@ void HP_clif_createchat(struct map_session_data *sd, int flag) { HPMHooks.source.clif.createchat(sd, flag); } if( HPMHooks.count.HP_clif_createchat_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_createchat_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -12277,11 +12302,11 @@ void HP_clif_createchat(struct map_session_data *sd, int flag) { void HP_clif_dispchat(struct chat_data *cd, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_dispchat_pre ) { - void (*preHookFunc) (struct chat_data *cd, int *fd); + void (*preHookFunc) (struct chat_data **cd, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_dispchat_pre[hIndex].func; - preHookFunc(cd, &fd); + preHookFunc(&cd, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12292,10 +12317,10 @@ void HP_clif_dispchat(struct chat_data *cd, int fd) { HPMHooks.source.clif.dispchat(cd, fd); } if( HPMHooks.count.HP_clif_dispchat_post ) { - void (*postHookFunc) (struct chat_data *cd, int *fd); + void (*postHookFunc) (struct chat_data *cd, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_dispchat_post[hIndex].func; - postHookFunc(cd, &fd); + postHookFunc(cd, fd); } } return; @@ -12303,11 +12328,11 @@ void HP_clif_dispchat(struct chat_data *cd, int fd) { void HP_clif_joinchatfail(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_joinchatfail_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_joinchatfail_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12318,10 +12343,10 @@ void HP_clif_joinchatfail(struct map_session_data *sd, int flag) { HPMHooks.source.clif.joinchatfail(sd, flag); } if( HPMHooks.count.HP_clif_joinchatfail_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_joinchatfail_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -12329,11 +12354,11 @@ void HP_clif_joinchatfail(struct map_session_data *sd, int flag) { void HP_clif_joinchatok(struct map_session_data *sd, struct chat_data *cd) { int hIndex = 0; if( HPMHooks.count.HP_clif_joinchatok_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct chat_data *cd); + void (*preHookFunc) (struct map_session_data **sd, struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_joinchatok_pre[hIndex].func; - preHookFunc(sd, cd); + preHookFunc(&sd, &cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12355,11 +12380,11 @@ void HP_clif_joinchatok(struct map_session_data *sd, struct chat_data *cd) { void HP_clif_addchat(struct chat_data *cd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_addchat_pre ) { - void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd); + void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addchat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_addchat_pre[hIndex].func; - preHookFunc(cd, sd); + preHookFunc(&cd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12381,11 +12406,11 @@ void HP_clif_addchat(struct chat_data *cd, struct map_session_data *sd) { void HP_clif_changechatowner(struct chat_data *cd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_changechatowner_pre ) { - void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd); + void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatowner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changechatowner_pre[hIndex].func; - preHookFunc(cd, sd); + preHookFunc(&cd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12407,11 +12432,11 @@ void HP_clif_changechatowner(struct chat_data *cd, struct map_session_data *sd) void HP_clif_clearchat(struct chat_data *cd, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_clearchat_pre ) { - void (*preHookFunc) (struct chat_data *cd, int *fd); + void (*preHookFunc) (struct chat_data **cd, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_clearchat_pre[hIndex].func; - preHookFunc(cd, &fd); + preHookFunc(&cd, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12422,10 +12447,10 @@ void HP_clif_clearchat(struct chat_data *cd, int fd) { HPMHooks.source.clif.clearchat(cd, fd); } if( HPMHooks.count.HP_clif_clearchat_post ) { - void (*postHookFunc) (struct chat_data *cd, int *fd); + void (*postHookFunc) (struct chat_data *cd, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_clearchat_post[hIndex].func; - postHookFunc(cd, &fd); + postHookFunc(cd, fd); } } return; @@ -12433,11 +12458,11 @@ void HP_clif_clearchat(struct chat_data *cd, int fd) { void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_leavechat_pre ) { - void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_leavechat_pre[hIndex].func; - preHookFunc(cd, sd, &flag); + preHookFunc(&cd, &sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12448,10 +12473,10 @@ void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool f HPMHooks.source.clif.leavechat(cd, sd, flag); } if( HPMHooks.count.HP_clif_leavechat_post ) { - void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_leavechat_post[hIndex].func; - postHookFunc(cd, sd, &flag); + postHookFunc(cd, sd, flag); } } return; @@ -12459,11 +12484,11 @@ void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool f void HP_clif_changechatstatus(struct chat_data *cd) { int hIndex = 0; if( HPMHooks.count.HP_clif_changechatstatus_pre ) { - void (*preHookFunc) (struct chat_data *cd); + void (*preHookFunc) (struct chat_data **cd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatstatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_changechatstatus_pre[hIndex].func; - preHookFunc(cd); + preHookFunc(&cd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12482,14 +12507,14 @@ void HP_clif_changechatstatus(struct chat_data *cd) { } return; } -void HP_clif_wis_message(int fd, const char *nick, const char *mes, size_t mes_len) { +void HP_clif_wis_message(int fd, const char *nick, const char *mes, int mes_len) { int hIndex = 0; if( HPMHooks.count.HP_clif_wis_message_pre ) { - void (*preHookFunc) (int *fd, const char *nick, const char *mes, size_t *mes_len); + void (*preHookFunc) (int *fd, const char **nick, const char **mes, int *mes_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_wis_message_pre[hIndex].func; - preHookFunc(&fd, nick, mes, &mes_len); + preHookFunc(&fd, &nick, &mes, &mes_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12500,10 +12525,10 @@ void HP_clif_wis_message(int fd, const char *nick, const char *mes, size_t mes_l HPMHooks.source.clif.wis_message(fd, nick, mes, mes_len); } if( HPMHooks.count.HP_clif_wis_message_post ) { - void (*postHookFunc) (int *fd, const char *nick, const char *mes, size_t *mes_len); + void (*postHookFunc) (int fd, const char *nick, const char *mes, int mes_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_wis_message_post[hIndex].func; - postHookFunc(&fd, nick, mes, &mes_len); + postHookFunc(fd, nick, mes, mes_len); } } return; @@ -12526,22 +12551,22 @@ void HP_clif_wis_end(int fd, int flag) { HPMHooks.source.clif.wis_end(fd, flag); } if( HPMHooks.count.HP_clif_wis_end_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_wis_end_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; } -void HP_clif_disp_message(struct block_list *src, const char *mes, size_t len, enum send_target target) { +void HP_clif_disp_message(struct block_list *src, const char *mes, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_disp_message_pre ) { - void (*preHookFunc) (struct block_list *src, const char *mes, size_t *len, enum send_target *target); + void (*preHookFunc) (struct block_list **src, const char **mes, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_disp_message_pre[hIndex].func; - preHookFunc(src, mes, &len, &target); + preHookFunc(&src, &mes, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12549,25 +12574,25 @@ void HP_clif_disp_message(struct block_list *src, const char *mes, size_t len, e } } { - HPMHooks.source.clif.disp_message(src, mes, len, target); + HPMHooks.source.clif.disp_message(src, mes, target); } if( HPMHooks.count.HP_clif_disp_message_post ) { - void (*postHookFunc) (struct block_list *src, const char *mes, size_t *len, enum send_target *target); + void (*postHookFunc) (struct block_list *src, const char *mes, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_disp_message_post[hIndex].func; - postHookFunc(src, mes, &len, &target); + postHookFunc(src, mes, target); } } return; } -void HP_clif_broadcast(struct block_list *bl, const char *mes, size_t len, int type, enum send_target target) { +void HP_clif_broadcast(struct block_list *bl, const char *mes, int len, int type, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_broadcast_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *mes, size_t *len, int *type, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, const char **mes, int *len, int *type, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_broadcast_pre[hIndex].func; - preHookFunc(bl, mes, &len, &type, &target); + preHookFunc(&bl, &mes, &len, &type, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12578,22 +12603,22 @@ void HP_clif_broadcast(struct block_list *bl, const char *mes, size_t len, int t HPMHooks.source.clif.broadcast(bl, mes, len, type, target); } if( HPMHooks.count.HP_clif_broadcast_post ) { - void (*postHookFunc) (struct block_list *bl, const char *mes, size_t *len, int *type, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, const char *mes, int len, int type, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_broadcast_post[hIndex].func; - postHookFunc(bl, mes, &len, &type, &target); + postHookFunc(bl, mes, len, type, target); } } return; } -void HP_clif_broadcast2(struct block_list *bl, const char *mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) { +void HP_clif_broadcast2(struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_broadcast2_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target); + void (*preHookFunc) (struct block_list **bl, const char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_broadcast2_pre[hIndex].func; - preHookFunc(bl, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &target); + preHookFunc(&bl, &mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12604,10 +12629,10 @@ void HP_clif_broadcast2(struct block_list *bl, const char *mes, size_t len, unsi HPMHooks.source.clif.broadcast2(bl, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, target); } if( HPMHooks.count.HP_clif_broadcast2_post ) { - void (*postHookFunc) (struct block_list *bl, const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target); + void (*postHookFunc) (struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_broadcast2_post[hIndex].func; - postHookFunc(bl, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &target); + postHookFunc(bl, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, target); } } return; @@ -12615,11 +12640,11 @@ void HP_clif_broadcast2(struct block_list *bl, const char *mes, size_t len, unsi void HP_clif_messagecolor_self(int fd, uint32 color, const char *msg) { int hIndex = 0; if( HPMHooks.count.HP_clif_messagecolor_self_pre ) { - void (*preHookFunc) (int *fd, uint32 *color, const char *msg); + void (*preHookFunc) (int *fd, uint32 *color, const char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_self_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_messagecolor_self_pre[hIndex].func; - preHookFunc(&fd, &color, msg); + preHookFunc(&fd, &color, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12630,10 +12655,10 @@ void HP_clif_messagecolor_self(int fd, uint32 color, const char *msg) { HPMHooks.source.clif.messagecolor_self(fd, color, msg); } if( HPMHooks.count.HP_clif_messagecolor_self_post ) { - void (*postHookFunc) (int *fd, uint32 *color, const char *msg); + void (*postHookFunc) (int fd, uint32 color, const char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_self_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_messagecolor_self_post[hIndex].func; - postHookFunc(&fd, &color, msg); + postHookFunc(fd, color, msg); } } return; @@ -12641,11 +12666,11 @@ void HP_clif_messagecolor_self(int fd, uint32 color, const char *msg) { void HP_clif_messagecolor(struct block_list *bl, uint32 color, const char *msg) { int hIndex = 0; if( HPMHooks.count.HP_clif_messagecolor_pre ) { - void (*preHookFunc) (struct block_list *bl, uint32 *color, const char *msg); + void (*preHookFunc) (struct block_list **bl, uint32 *color, const char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_messagecolor_pre[hIndex].func; - preHookFunc(bl, &color, msg); + preHookFunc(&bl, &color, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12656,10 +12681,10 @@ void HP_clif_messagecolor(struct block_list *bl, uint32 color, const char *msg) HPMHooks.source.clif.messagecolor(bl, color, msg); } if( HPMHooks.count.HP_clif_messagecolor_post ) { - void (*postHookFunc) (struct block_list *bl, uint32 *color, const char *msg); + void (*postHookFunc) (struct block_list *bl, uint32 color, const char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_messagecolor_post[hIndex].func; - postHookFunc(bl, &color, msg); + postHookFunc(bl, color, msg); } } return; @@ -12667,11 +12692,11 @@ void HP_clif_messagecolor(struct block_list *bl, uint32 color, const char *msg) void HP_clif_disp_overhead(struct block_list *bl, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_disp_overhead_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *mes); + void (*preHookFunc) (struct block_list **bl, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_overhead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_disp_overhead_pre[hIndex].func; - preHookFunc(bl, mes); + preHookFunc(&bl, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12693,11 +12718,11 @@ void HP_clif_disp_overhead(struct block_list *bl, const char *mes) { void HP_clif_msgtable(struct map_session_data *sd, unsigned short msg_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_msgtable_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *msg_id); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *msg_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_msgtable_pre[hIndex].func; - preHookFunc(sd, &msg_id); + preHookFunc(&sd, &msg_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12708,10 +12733,10 @@ void HP_clif_msgtable(struct map_session_data *sd, unsigned short msg_id) { HPMHooks.source.clif.msgtable(sd, msg_id); } if( HPMHooks.count.HP_clif_msgtable_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *msg_id); + void (*postHookFunc) (struct map_session_data *sd, unsigned short msg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_msgtable_post[hIndex].func; - postHookFunc(sd, &msg_id); + postHookFunc(sd, msg_id); } } return; @@ -12719,11 +12744,11 @@ void HP_clif_msgtable(struct map_session_data *sd, unsigned short msg_id) { void HP_clif_msgtable_num(struct map_session_data *sd, unsigned short msg_id, int value) { int hIndex = 0; if( HPMHooks.count.HP_clif_msgtable_num_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *msg_id, int *value); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *msg_id, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_msgtable_num_pre[hIndex].func; - preHookFunc(sd, &msg_id, &value); + preHookFunc(&sd, &msg_id, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12734,10 +12759,10 @@ void HP_clif_msgtable_num(struct map_session_data *sd, unsigned short msg_id, in HPMHooks.source.clif.msgtable_num(sd, msg_id, value); } if( HPMHooks.count.HP_clif_msgtable_num_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *msg_id, int *value); + void (*postHookFunc) (struct map_session_data *sd, unsigned short msg_id, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_msgtable_num_post[hIndex].func; - postHookFunc(sd, &msg_id, &value); + postHookFunc(sd, msg_id, value); } } return; @@ -12745,11 +12770,11 @@ void HP_clif_msgtable_num(struct map_session_data *sd, unsigned short msg_id, in void HP_clif_msgtable_skill(struct map_session_data *sd, uint16 skill_id, int msg_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_msgtable_skill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *msg_id); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, int *msg_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_skill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_msgtable_skill_pre[hIndex].func; - preHookFunc(sd, &skill_id, &msg_id); + preHookFunc(&sd, &skill_id, &msg_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12760,10 +12785,10 @@ void HP_clif_msgtable_skill(struct map_session_data *sd, uint16 skill_id, int ms HPMHooks.source.clif.msgtable_skill(sd, skill_id, msg_id); } if( HPMHooks.count.HP_clif_msgtable_skill_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *msg_id); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, int msg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_skill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_msgtable_skill_post[hIndex].func; - postHookFunc(sd, &skill_id, &msg_id); + postHookFunc(sd, skill_id, msg_id); } } return; @@ -12771,11 +12796,11 @@ void HP_clif_msgtable_skill(struct map_session_data *sd, uint16 skill_id, int ms void HP_clif_message(const int fd, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_message_pre ) { - void (*preHookFunc) (const int *fd, const char *mes); + void (*preHookFunc) (const int *fd, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_message_pre[hIndex].func; - preHookFunc(&fd, mes); + preHookFunc(&fd, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12786,10 +12811,10 @@ void HP_clif_message(const int fd, const char *mes) { HPMHooks.source.clif.message(fd, mes); } if( HPMHooks.count.HP_clif_message_post ) { - void (*postHookFunc) (const int *fd, const char *mes); + void (*postHookFunc) (const int fd, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_message_post[hIndex].func; - postHookFunc(&fd, mes); + postHookFunc(fd, mes); } } return; @@ -12797,11 +12822,11 @@ void HP_clif_message(const int fd, const char *mes) { void HP_clif_messageln(const int fd, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_messageln_pre ) { - void (*preHookFunc) (const int *fd, const char *mes); + void (*preHookFunc) (const int *fd, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_messageln_pre[hIndex].func; - preHookFunc(&fd, mes); + preHookFunc(&fd, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12812,23 +12837,50 @@ void HP_clif_messageln(const int fd, const char *mes) { HPMHooks.source.clif.messageln(fd, mes); } if( HPMHooks.count.HP_clif_messageln_post ) { - void (*postHookFunc) (const int *fd, const char *mes); + void (*postHookFunc) (const int fd, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_messageln_post[hIndex].func; - postHookFunc(&fd, mes); + postHookFunc(fd, mes); } } return; } -bool HP_clif_process_message(struct map_session_data *sd, int format, const char **name_, size_t *namelen_, const char **message_, size_t *messagelen_) { +const char* HP_clif_process_chat_message(struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_clif_process_chat_message_pre ) { + const char* (*preHookFunc) (struct map_session_data **sd, const struct packet_chat_message **packet, char **out_buf, int *out_buflen); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_chat_message_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_clif_process_chat_message_pre[hIndex].func; + retVal___ = preHookFunc(&sd, &packet, &out_buf, &out_buflen); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.clif.process_chat_message(sd, packet, out_buf, out_buflen); + } + if( HPMHooks.count.HP_clif_process_chat_message_post ) { + const char* (*postHookFunc) (const char* retVal___, struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_chat_message_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_clif_process_chat_message_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sd, packet, out_buf, out_buflen); + } + } + return retVal___; +} +bool HP_clif_process_whisper_message(struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen) { int hIndex = 0; bool retVal___ = false; - if( HPMHooks.count.HP_clif_process_message_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *format, const char **name_, size_t *namelen_, const char **message_, size_t *messagelen_); + if( HPMHooks.count.HP_clif_process_whisper_message_pre ) { + bool (*preHookFunc) (struct map_session_data **sd, const struct packet_whisper_message **packet, char **out_name, char **out_message, int *out_messagelen); *HPMforce_return = false; - for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_message_pre; hIndex++ ) { - preHookFunc = HPMHooks.list.HP_clif_process_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, &format, name_, namelen_, message_, messagelen_); + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_whisper_message_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_clif_process_whisper_message_pre[hIndex].func; + retVal___ = preHookFunc(&sd, &packet, &out_name, &out_message, &out_messagelen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12836,13 +12888,13 @@ bool HP_clif_process_message(struct map_session_data *sd, int format, const char } } { - retVal___ = HPMHooks.source.clif.process_message(sd, format, name_, namelen_, message_, messagelen_); + retVal___ = HPMHooks.source.clif.process_whisper_message(sd, packet, out_name, out_message, out_messagelen); } - if( HPMHooks.count.HP_clif_process_message_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *format, const char **name_, size_t *namelen_, const char **message_, size_t *messagelen_); - for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_message_post; hIndex++ ) { - postHookFunc = HPMHooks.list.HP_clif_process_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &format, name_, namelen_, message_, messagelen_); + if( HPMHooks.count.HP_clif_process_whisper_message_post ) { + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen); + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_whisper_message_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_clif_process_whisper_message_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sd, packet, out_name, out_message, out_messagelen); } } return retVal___; @@ -12850,11 +12902,11 @@ bool HP_clif_process_message(struct map_session_data *sd, int format, const char void HP_clif_wisexin(struct map_session_data *sd, int type, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_wisexin_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *type, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_wisexin_pre[hIndex].func; - preHookFunc(sd, &type, &flag); + preHookFunc(&sd, &type, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12865,10 +12917,10 @@ void HP_clif_wisexin(struct map_session_data *sd, int type, int flag) { HPMHooks.source.clif.wisexin(sd, type, flag); } if( HPMHooks.count.HP_clif_wisexin_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_wisexin_post[hIndex].func; - postHookFunc(sd, &type, &flag); + postHookFunc(sd, type, flag); } } return; @@ -12876,11 +12928,11 @@ void HP_clif_wisexin(struct map_session_data *sd, int type, int flag) { void HP_clif_wisall(struct map_session_data *sd, int type, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_wisall_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *type, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_wisall_pre[hIndex].func; - preHookFunc(sd, &type, &flag); + preHookFunc(&sd, &type, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12891,10 +12943,10 @@ void HP_clif_wisall(struct map_session_data *sd, int type, int flag) { HPMHooks.source.clif.wisall(sd, type, flag); } if( HPMHooks.count.HP_clif_wisall_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_wisall_post[hIndex].func; - postHookFunc(sd, &type, &flag); + postHookFunc(sd, type, flag); } } return; @@ -12902,11 +12954,11 @@ void HP_clif_wisall(struct map_session_data *sd, int type, int flag) { void HP_clif_PMIgnoreList(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PMIgnoreList_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PMIgnoreList_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PMIgnoreList_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12928,11 +12980,11 @@ void HP_clif_PMIgnoreList(struct map_session_data *sd) { void HP_clif_ShowScript(struct block_list *bl, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_clif_ShowScript_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *message); + void (*preHookFunc) (struct block_list **bl, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ShowScript_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_ShowScript_pre[hIndex].func; - preHookFunc(bl, message); + preHookFunc(&bl, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12954,11 +13006,11 @@ void HP_clif_ShowScript(struct block_list *bl, const char *message) { void HP_clif_traderequest(struct map_session_data *sd, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_traderequest_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name); + void (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_traderequest_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_traderequest_pre[hIndex].func; - preHookFunc(sd, name); + preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12980,11 +13032,11 @@ void HP_clif_traderequest(struct map_session_data *sd, const char *name) { void HP_clif_tradestart(struct map_session_data *sd, uint8 type) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradestart_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint8 *type); + void (*preHookFunc) (struct map_session_data **sd, uint8 *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradestart_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -12995,10 +13047,10 @@ void HP_clif_tradestart(struct map_session_data *sd, uint8 type) { HPMHooks.source.clif.tradestart(sd, type); } if( HPMHooks.count.HP_clif_tradestart_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint8 *type); + void (*postHookFunc) (struct map_session_data *sd, uint8 type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_tradestart_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -13006,11 +13058,11 @@ void HP_clif_tradestart(struct map_session_data *sd, uint8 type) { void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data *tsd, int index, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradeadditem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int *index, int *amount); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeadditem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradeadditem_pre[hIndex].func; - preHookFunc(sd, tsd, &index, &amount); + preHookFunc(&sd, &tsd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13021,10 +13073,10 @@ void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data * HPMHooks.source.clif.tradeadditem(sd, tsd, index, amount); } if( HPMHooks.count.HP_clif_tradeadditem_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int *index, int *amount); + void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeadditem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_tradeadditem_post[hIndex].func; - postHookFunc(sd, tsd, &index, &amount); + postHookFunc(sd, tsd, index, amount); } } return; @@ -13032,11 +13084,11 @@ void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data * void HP_clif_tradeitemok(struct map_session_data *sd, int index, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradeitemok_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *index, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradeitemok_pre[hIndex].func; - preHookFunc(sd, &index, &fail); + preHookFunc(&sd, &index, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13047,10 +13099,10 @@ void HP_clif_tradeitemok(struct map_session_data *sd, int index, int fail) { HPMHooks.source.clif.tradeitemok(sd, index, fail); } if( HPMHooks.count.HP_clif_tradeitemok_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int index, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_tradeitemok_post[hIndex].func; - postHookFunc(sd, &index, &fail); + postHookFunc(sd, index, fail); } } return; @@ -13058,11 +13110,11 @@ void HP_clif_tradeitemok(struct map_session_data *sd, int index, int fail) { void HP_clif_tradedeal_lock(struct map_session_data *sd, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradedeal_lock_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradedeal_lock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradedeal_lock_pre[hIndex].func; - preHookFunc(sd, &fail); + preHookFunc(&sd, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13073,10 +13125,10 @@ void HP_clif_tradedeal_lock(struct map_session_data *sd, int fail) { HPMHooks.source.clif.tradedeal_lock(sd, fail); } if( HPMHooks.count.HP_clif_tradedeal_lock_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradedeal_lock_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_tradedeal_lock_post[hIndex].func; - postHookFunc(sd, &fail); + postHookFunc(sd, fail); } } return; @@ -13084,11 +13136,11 @@ void HP_clif_tradedeal_lock(struct map_session_data *sd, int fail) { void HP_clif_tradecancelled(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradecancelled_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecancelled_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradecancelled_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13110,11 +13162,11 @@ void HP_clif_tradecancelled(struct map_session_data *sd) { void HP_clif_tradecompleted(struct map_session_data *sd, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradecompleted_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradecompleted_pre[hIndex].func; - preHookFunc(sd, &fail); + preHookFunc(&sd, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13125,10 +13177,10 @@ void HP_clif_tradecompleted(struct map_session_data *sd, int fail) { HPMHooks.source.clif.tradecompleted(sd, fail); } if( HPMHooks.count.HP_clif_tradecompleted_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_tradecompleted_post[hIndex].func; - postHookFunc(sd, &fail); + postHookFunc(sd, fail); } } return; @@ -13136,11 +13188,11 @@ void HP_clif_tradecompleted(struct map_session_data *sd, int fail) { void HP_clif_tradeundo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_tradeundo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeundo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_tradeundo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13162,11 +13214,11 @@ void HP_clif_tradeundo(struct map_session_data *sd) { void HP_clif_openvendingreq(struct map_session_data *sd, int num) { int hIndex = 0; if( HPMHooks.count.HP_clif_openvendingreq_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *num); + void (*preHookFunc) (struct map_session_data **sd, int *num); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_openvendingreq_pre[hIndex].func; - preHookFunc(sd, &num); + preHookFunc(&sd, &num); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13177,10 +13229,10 @@ void HP_clif_openvendingreq(struct map_session_data *sd, int num) { HPMHooks.source.clif.openvendingreq(sd, num); } if( HPMHooks.count.HP_clif_openvendingreq_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *num); + void (*postHookFunc) (struct map_session_data *sd, int num); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_openvendingreq_post[hIndex].func; - postHookFunc(sd, &num); + postHookFunc(sd, num); } } return; @@ -13188,11 +13240,11 @@ void HP_clif_openvendingreq(struct map_session_data *sd, int num) { void HP_clif_showvendingboard(struct block_list *bl, const char *message, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_showvendingboard_pre ) { - void (*preHookFunc) (struct block_list *bl, const char *message, int *fd); + void (*preHookFunc) (struct block_list **bl, const char **message, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_showvendingboard_pre[hIndex].func; - preHookFunc(bl, message, &fd); + preHookFunc(&bl, &message, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13203,10 +13255,10 @@ void HP_clif_showvendingboard(struct block_list *bl, const char *message, int fd HPMHooks.source.clif.showvendingboard(bl, message, fd); } if( HPMHooks.count.HP_clif_showvendingboard_post ) { - void (*postHookFunc) (struct block_list *bl, const char *message, int *fd); + void (*postHookFunc) (struct block_list *bl, const char *message, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_showvendingboard_post[hIndex].func; - postHookFunc(bl, message, &fd); + postHookFunc(bl, message, fd); } } return; @@ -13214,11 +13266,11 @@ void HP_clif_showvendingboard(struct block_list *bl, const char *message, int fd void HP_clif_closevendingboard(struct block_list *bl, int fd) { int hIndex = 0; if( HPMHooks.count.HP_clif_closevendingboard_pre ) { - void (*preHookFunc) (struct block_list *bl, int *fd); + void (*preHookFunc) (struct block_list **bl, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_closevendingboard_pre[hIndex].func; - preHookFunc(bl, &fd); + preHookFunc(&bl, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13229,10 +13281,10 @@ void HP_clif_closevendingboard(struct block_list *bl, int fd) { HPMHooks.source.clif.closevendingboard(bl, fd); } if( HPMHooks.count.HP_clif_closevendingboard_post ) { - void (*postHookFunc) (struct block_list *bl, int *fd); + void (*postHookFunc) (struct block_list *bl, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_closevendingboard_post[hIndex].func; - postHookFunc(bl, &fd); + postHookFunc(bl, fd); } } return; @@ -13240,11 +13292,11 @@ void HP_clif_closevendingboard(struct block_list *bl, int fd) { void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_vending *vending_list) { int hIndex = 0; if( HPMHooks.count.HP_clif_vendinglist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *id, struct s_vending *vending_list); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *id, struct s_vending **vending_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendinglist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_vendinglist_pre[hIndex].func; - preHookFunc(sd, &id, vending_list); + preHookFunc(&sd, &id, &vending_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13255,10 +13307,10 @@ void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_ HPMHooks.source.clif.vendinglist(sd, id, vending_list); } if( HPMHooks.count.HP_clif_vendinglist_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *id, struct s_vending *vending_list); + void (*postHookFunc) (struct map_session_data *sd, unsigned int id, struct s_vending *vending_list); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendinglist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_vendinglist_post[hIndex].func; - postHookFunc(sd, &id, vending_list); + postHookFunc(sd, id, vending_list); } } return; @@ -13266,11 +13318,11 @@ void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_ void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyvending_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyvending_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyvending_pre[hIndex].func; - preHookFunc(sd, &index, &amount, &fail); + preHookFunc(&sd, &index, &amount, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13281,10 +13333,10 @@ void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int HPMHooks.source.clif.buyvending(sd, index, amount, fail); } if( HPMHooks.count.HP_clif_buyvending_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int index, int amount, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyvending_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyvending_post[hIndex].func; - postHookFunc(sd, &index, &amount, &fail); + postHookFunc(sd, index, amount, fail); } } return; @@ -13292,11 +13344,11 @@ void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending *vending_list) { int hIndex = 0; if( HPMHooks.count.HP_clif_openvending_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *id, struct s_vending *vending_list); + void (*preHookFunc) (struct map_session_data **sd, int *id, struct s_vending **vending_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvending_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_openvending_pre[hIndex].func; - preHookFunc(sd, &id, vending_list); + preHookFunc(&sd, &id, &vending_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13307,10 +13359,10 @@ void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending * HPMHooks.source.clif.openvending(sd, id, vending_list); } if( HPMHooks.count.HP_clif_openvending_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *id, struct s_vending *vending_list); + void (*postHookFunc) (struct map_session_data *sd, int id, struct s_vending *vending_list); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvending_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_openvending_post[hIndex].func; - postHookFunc(sd, &id, vending_list); + postHookFunc(sd, id, vending_list); } } return; @@ -13318,11 +13370,11 @@ void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending * void HP_clif_vendingreport(struct map_session_data *sd, int index, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_vendingreport_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_vendingreport_pre[hIndex].func; - preHookFunc(sd, &index, &amount); + preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13333,10 +13385,10 @@ void HP_clif_vendingreport(struct map_session_data *sd, int index, int amount) { HPMHooks.source.clif.vendingreport(sd, index, amount); } if( HPMHooks.count.HP_clif_vendingreport_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount); + void (*postHookFunc) (struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_vendingreport_post[hIndex].func; - postHookFunc(sd, &index, &amount); + postHookFunc(sd, index, amount); } } return; @@ -13344,11 +13396,11 @@ void HP_clif_vendingreport(struct map_session_data *sd, int index, int amount) { void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int items_length) { int hIndex = 0; if( HPMHooks.count.HP_clif_storagelist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item *items, int *items_length); + void (*preHookFunc) (struct map_session_data **sd, struct item **items, int *items_length); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storagelist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_storagelist_pre[hIndex].func; - preHookFunc(sd, items, &items_length); + preHookFunc(&sd, &items, &items_length); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13359,10 +13411,10 @@ void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int it HPMHooks.source.clif.storagelist(sd, items, items_length); } if( HPMHooks.count.HP_clif_storagelist_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item *items, int *items_length); + void (*postHookFunc) (struct map_session_data *sd, struct item *items, int items_length); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storagelist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_storagelist_post[hIndex].func; - postHookFunc(sd, items, &items_length); + postHookFunc(sd, items, items_length); } } return; @@ -13370,11 +13422,11 @@ void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int it void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int max_amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_updatestorageamount_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *amount, int *max_amount); + void (*preHookFunc) (struct map_session_data **sd, int *amount, int *max_amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestorageamount_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_updatestorageamount_pre[hIndex].func; - preHookFunc(sd, &amount, &max_amount); + preHookFunc(&sd, &amount, &max_amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13385,10 +13437,10 @@ void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int ma HPMHooks.source.clif.updatestorageamount(sd, amount, max_amount); } if( HPMHooks.count.HP_clif_updatestorageamount_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *amount, int *max_amount); + void (*postHookFunc) (struct map_session_data *sd, int amount, int max_amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestorageamount_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_updatestorageamount_post[hIndex].func; - postHookFunc(sd, &amount, &max_amount); + postHookFunc(sd, amount, max_amount); } } return; @@ -13396,11 +13448,11 @@ void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int ma void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int index, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_storageitemadded_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item *i, int *index, int *amount); + void (*preHookFunc) (struct map_session_data **sd, struct item **i, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemadded_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_storageitemadded_pre[hIndex].func; - preHookFunc(sd, i, &index, &amount); + preHookFunc(&sd, &i, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13411,10 +13463,10 @@ void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int i HPMHooks.source.clif.storageitemadded(sd, i, index, amount); } if( HPMHooks.count.HP_clif_storageitemadded_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item *i, int *index, int *amount); + void (*postHookFunc) (struct map_session_data *sd, struct item *i, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemadded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_storageitemadded_post[hIndex].func; - postHookFunc(sd, i, &index, &amount); + postHookFunc(sd, i, index, amount); } } return; @@ -13422,11 +13474,11 @@ void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int i void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_storageitemremoved_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_storageitemremoved_pre[hIndex].func; - preHookFunc(sd, &index, &amount); + preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13437,10 +13489,10 @@ void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amou HPMHooks.source.clif.storageitemremoved(sd, index, amount); } if( HPMHooks.count.HP_clif_storageitemremoved_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount); + void (*postHookFunc) (struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_storageitemremoved_post[hIndex].func; - postHookFunc(sd, &index, &amount); + postHookFunc(sd, index, amount); } } return; @@ -13448,11 +13500,11 @@ void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amou void HP_clif_storageclose(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_storageclose_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageclose_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_storageclose_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13474,11 +13526,11 @@ void HP_clif_storageclose(struct map_session_data *sd) { void HP_clif_skillinfoblock(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillinfoblock_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfoblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillinfoblock_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13500,11 +13552,11 @@ void HP_clif_skillinfoblock(struct map_session_data *sd) { void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id, int skill_lv, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillup_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *skill_lv, int *flag); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, int *skill_lv, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillup_pre[hIndex].func; - preHookFunc(sd, &skill_id, &skill_lv, &flag); + preHookFunc(&sd, &skill_id, &skill_lv, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13515,10 +13567,10 @@ void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id, int skill_lv, HPMHooks.source.clif.skillup(sd, skill_id, skill_lv, flag); } if( HPMHooks.count.HP_clif_skillup_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *skill_lv, int *flag); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, int skill_lv, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skillup_post[hIndex].func; - postHookFunc(sd, &skill_id, &skill_lv, &flag); + postHookFunc(sd, skill_id, skill_lv, flag); } } return; @@ -13526,11 +13578,11 @@ void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id, int skill_lv, void HP_clif_skillinfo(struct map_session_data *sd, int skill_id, int inf) { int hIndex = 0; if( HPMHooks.count.HP_clif_skillinfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *inf); + void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *inf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_skillinfo_pre[hIndex].func; - preHookFunc(sd, &skill_id, &inf); + preHookFunc(&sd, &skill_id, &inf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13541,10 +13593,10 @@ void HP_clif_skillinfo(struct map_session_data *sd, int skill_id, int inf) { HPMHooks.source.clif.skillinfo(sd, skill_id, inf); } if( HPMHooks.count.HP_clif_skillinfo_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *inf); + void (*postHookFunc) (struct map_session_data *sd, int skill_id, int inf); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_skillinfo_post[hIndex].func; - postHookFunc(sd, &skill_id, &inf); + postHookFunc(sd, skill_id, inf); } } return; @@ -13552,11 +13604,11 @@ void HP_clif_skillinfo(struct map_session_data *sd, int skill_id, int inf) { void HP_clif_addskill(struct map_session_data *sd, int id) { int hIndex = 0; if( HPMHooks.count.HP_clif_addskill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *id); + void (*preHookFunc) (struct map_session_data **sd, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_addskill_pre[hIndex].func; - preHookFunc(sd, &id); + preHookFunc(&sd, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13567,10 +13619,10 @@ void HP_clif_addskill(struct map_session_data *sd, int id) { HPMHooks.source.clif.addskill(sd, id); } if( HPMHooks.count.HP_clif_addskill_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *id); + void (*postHookFunc) (struct map_session_data *sd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_addskill_post[hIndex].func; - postHookFunc(sd, &id); + postHookFunc(sd, id); } } return; @@ -13578,11 +13630,11 @@ void HP_clif_addskill(struct map_session_data *sd, int id) { void HP_clif_deleteskill(struct map_session_data *sd, int id) { int hIndex = 0; if( HPMHooks.count.HP_clif_deleteskill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *id); + void (*preHookFunc) (struct map_session_data **sd, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_deleteskill_pre[hIndex].func; - preHookFunc(sd, &id); + preHookFunc(&sd, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13593,10 +13645,10 @@ void HP_clif_deleteskill(struct map_session_data *sd, int id) { HPMHooks.source.clif.deleteskill(sd, id); } if( HPMHooks.count.HP_clif_deleteskill_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *id); + void (*postHookFunc) (struct map_session_data *sd, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_deleteskill_post[hIndex].func; - postHookFunc(sd, &id); + postHookFunc(sd, id); } } return; @@ -13604,11 +13656,11 @@ void HP_clif_deleteskill(struct map_session_data *sd, int id) { void HP_clif_party_created(struct map_session_data *sd, int result) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_created_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *result); + void (*preHookFunc) (struct map_session_data **sd, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_created_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13619,10 +13671,10 @@ void HP_clif_party_created(struct map_session_data *sd, int result) { HPMHooks.source.clif.party_created(sd, result); } if( HPMHooks.count.HP_clif_party_created_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *result); + void (*postHookFunc) (struct map_session_data *sd, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_created_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -13630,11 +13682,11 @@ void HP_clif_party_created(struct map_session_data *sd, int result) { void HP_clif_party_member_info(struct party_data *p, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_member_info_pre ) { - void (*preHookFunc) (struct party_data *p, struct map_session_data *sd); + void (*preHookFunc) (struct party_data **p, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_member_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_member_info_pre[hIndex].func; - preHookFunc(p, sd); + preHookFunc(&p, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13656,11 +13708,11 @@ void HP_clif_party_member_info(struct party_data *p, struct map_session_data *sd void HP_clif_party_info(struct party_data *p, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_info_pre ) { - void (*preHookFunc) (struct party_data *p, struct map_session_data *sd); + void (*preHookFunc) (struct party_data **p, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_info_pre[hIndex].func; - preHookFunc(p, sd); + preHookFunc(&p, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13682,11 +13734,11 @@ void HP_clif_party_info(struct party_data *p, struct map_session_data *sd) { void HP_clif_party_invite(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_invite_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_invite_pre[hIndex].func; - preHookFunc(sd, tsd); + preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13708,11 +13760,11 @@ void HP_clif_party_invite(struct map_session_data *sd, struct map_session_data * void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int result) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_inviteack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *nick, int *result); + void (*preHookFunc) (struct map_session_data **sd, const char **nick, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_inviteack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_inviteack_pre[hIndex].func; - preHookFunc(sd, nick, &result); + preHookFunc(&sd, &nick, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13723,10 +13775,10 @@ void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int HPMHooks.source.clif.party_inviteack(sd, nick, result); } if( HPMHooks.count.HP_clif_party_inviteack_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *nick, int *result); + void (*postHookFunc) (struct map_session_data *sd, const char *nick, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_inviteack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_inviteack_post[hIndex].func; - postHookFunc(sd, nick, &result); + postHookFunc(sd, nick, result); } } return; @@ -13734,11 +13786,11 @@ void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_option_pre ) { - void (*preHookFunc) (struct party_data *p, struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct party_data **p, struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_option_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_option_pre[hIndex].func; - preHookFunc(p, sd, &flag); + preHookFunc(&p, &sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13749,10 +13801,10 @@ void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int HPMHooks.source.clif.party_option(p, sd, flag); } if( HPMHooks.count.HP_clif_party_option_post ) { - void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_option_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_option_post[hIndex].func; - postHookFunc(p, sd, &flag); + postHookFunc(p, sd, flag); } } return; @@ -13760,11 +13812,11 @@ void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_withdraw_pre ) { - void (*preHookFunc) (struct party_data *p, struct map_session_data *sd, int *account_id, const char *name, int *flag); + void (*preHookFunc) (struct party_data **p, struct map_session_data **sd, int *account_id, const char **name, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_withdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_withdraw_pre[hIndex].func; - preHookFunc(p, sd, &account_id, name, &flag); + preHookFunc(&p, &sd, &account_id, &name, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13775,10 +13827,10 @@ void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, i HPMHooks.source.clif.party_withdraw(p, sd, account_id, name, flag); } if( HPMHooks.count.HP_clif_party_withdraw_post ) { - void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int *account_id, const char *name, int *flag); + void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_withdraw_post[hIndex].func; - postHookFunc(p, sd, &account_id, name, &flag); + postHookFunc(p, sd, account_id, name, flag); } } return; @@ -13786,11 +13838,11 @@ void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, i void HP_clif_party_message(struct party_data *p, int account_id, const char *mes, int len) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_message_pre ) { - void (*preHookFunc) (struct party_data *p, int *account_id, const char *mes, int *len); + void (*preHookFunc) (struct party_data **p, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_message_pre[hIndex].func; - preHookFunc(p, &account_id, mes, &len); + preHookFunc(&p, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13801,10 +13853,10 @@ void HP_clif_party_message(struct party_data *p, int account_id, const char *mes HPMHooks.source.clif.party_message(p, account_id, mes, len); } if( HPMHooks.count.HP_clif_party_message_post ) { - void (*postHookFunc) (struct party_data *p, int *account_id, const char *mes, int *len); + void (*postHookFunc) (struct party_data *p, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_message_post[hIndex].func; - postHookFunc(p, &account_id, mes, &len); + postHookFunc(p, account_id, mes, len); } } return; @@ -13812,11 +13864,11 @@ void HP_clif_party_message(struct party_data *p, int account_id, const char *mes void HP_clif_party_xy(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_xy_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_xy_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13838,11 +13890,11 @@ void HP_clif_party_xy(struct map_session_data *sd) { void HP_clif_party_xy_single(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_xy_single_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_xy_single_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13853,10 +13905,10 @@ void HP_clif_party_xy_single(int fd, struct map_session_data *sd) { HPMHooks.source.clif.party_xy_single(fd, sd); } if( HPMHooks.count.HP_clif_party_xy_single_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_party_xy_single_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -13864,11 +13916,11 @@ void HP_clif_party_xy_single(int fd, struct map_session_data *sd) { void HP_clif_party_hp(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_hp_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_hp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_hp_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13890,11 +13942,11 @@ void HP_clif_party_hp(struct map_session_data *sd) { void HP_clif_party_xy_remove(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_xy_remove_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_xy_remove_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13916,11 +13968,11 @@ void HP_clif_party_xy_remove(struct map_session_data *sd) { void HP_clif_party_show_picker(struct map_session_data *sd, struct item *item_data) { int hIndex = 0; if( HPMHooks.count.HP_clif_party_show_picker_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item *item_data); + void (*preHookFunc) (struct map_session_data **sd, struct item **item_data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_show_picker_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_party_show_picker_pre[hIndex].func; - preHookFunc(sd, item_data); + preHookFunc(&sd, &item_data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13942,11 +13994,11 @@ void HP_clif_party_show_picker(struct map_session_data *sd, struct item *item_da void HP_clif_partyinvitationstate(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_partyinvitationstate_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partyinvitationstate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_partyinvitationstate_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13968,11 +14020,11 @@ void HP_clif_partyinvitationstate(struct map_session_data *sd) { void HP_clif_PartyLeaderChanged(struct map_session_data *sd, int prev_leader_aid, int new_leader_aid) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyLeaderChanged_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *prev_leader_aid, int *new_leader_aid); + void (*preHookFunc) (struct map_session_data **sd, int *prev_leader_aid, int *new_leader_aid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyLeaderChanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyLeaderChanged_pre[hIndex].func; - preHookFunc(sd, &prev_leader_aid, &new_leader_aid); + preHookFunc(&sd, &prev_leader_aid, &new_leader_aid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -13983,10 +14035,10 @@ void HP_clif_PartyLeaderChanged(struct map_session_data *sd, int prev_leader_aid HPMHooks.source.clif.PartyLeaderChanged(sd, prev_leader_aid, new_leader_aid); } if( HPMHooks.count.HP_clif_PartyLeaderChanged_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *prev_leader_aid, int *new_leader_aid); + void (*postHookFunc) (struct map_session_data *sd, int prev_leader_aid, int new_leader_aid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyLeaderChanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyLeaderChanged_post[hIndex].func; - postHookFunc(sd, &prev_leader_aid, &new_leader_aid); + postHookFunc(sd, prev_leader_aid, new_leader_aid); } } return; @@ -13994,11 +14046,11 @@ void HP_clif_PartyLeaderChanged(struct map_session_data *sd, int prev_leader_aid void HP_clif_guild_created(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_created_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_created_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14009,10 +14061,10 @@ void HP_clif_guild_created(struct map_session_data *sd, int flag) { HPMHooks.source.clif.guild_created(sd, flag); } if( HPMHooks.count.HP_clif_guild_created_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_created_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -14020,11 +14072,11 @@ void HP_clif_guild_created(struct map_session_data *sd, int flag) { void HP_clif_guild_belonginfo(struct map_session_data *sd, struct guild *g) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_belonginfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct guild *g); + void (*preHookFunc) (struct map_session_data **sd, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_belonginfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_belonginfo_pre[hIndex].func; - preHookFunc(sd, g); + preHookFunc(&sd, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14046,11 +14098,11 @@ void HP_clif_guild_belonginfo(struct map_session_data *sd, struct guild *g) { void HP_clif_guild_masterormember(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_masterormember_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_masterormember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_masterormember_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14072,11 +14124,11 @@ void HP_clif_guild_masterormember(struct map_session_data *sd) { void HP_clif_guild_basicinfo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_basicinfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_basicinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_basicinfo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14098,11 +14150,11 @@ void HP_clif_guild_basicinfo(struct map_session_data *sd) { void HP_clif_guild_allianceinfo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_allianceinfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_allianceinfo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14124,11 +14176,11 @@ void HP_clif_guild_allianceinfo(struct map_session_data *sd) { void HP_clif_guild_memberlist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_memberlist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_memberlist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14150,11 +14202,11 @@ void HP_clif_guild_memberlist(struct map_session_data *sd) { void HP_clif_guild_skillinfo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_skillinfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_skillinfo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14176,11 +14228,11 @@ void HP_clif_guild_skillinfo(struct map_session_data *sd) { void HP_clif_guild_send_onlineinfo(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_send_onlineinfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_send_onlineinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_send_onlineinfo_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14202,11 +14254,11 @@ void HP_clif_guild_send_onlineinfo(struct map_session_data *sd) { void HP_clif_guild_memberlogin_notice(struct guild *g, int idx, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_memberlogin_notice_pre ) { - void (*preHookFunc) (struct guild *g, int *idx, int *flag); + void (*preHookFunc) (struct guild **g, int *idx, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlogin_notice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_memberlogin_notice_pre[hIndex].func; - preHookFunc(g, &idx, &flag); + preHookFunc(&g, &idx, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14217,10 +14269,10 @@ void HP_clif_guild_memberlogin_notice(struct guild *g, int idx, int flag) { HPMHooks.source.clif.guild_memberlogin_notice(g, idx, flag); } if( HPMHooks.count.HP_clif_guild_memberlogin_notice_post ) { - void (*postHookFunc) (struct guild *g, int *idx, int *flag); + void (*postHookFunc) (struct guild *g, int idx, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlogin_notice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_memberlogin_notice_post[hIndex].func; - postHookFunc(g, &idx, &flag); + postHookFunc(g, idx, flag); } } return; @@ -14228,11 +14280,11 @@ void HP_clif_guild_memberlogin_notice(struct guild *g, int idx, int flag) { void HP_clif_guild_invite(struct map_session_data *sd, struct guild *g) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_invite_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct guild *g); + void (*preHookFunc) (struct map_session_data **sd, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_invite_pre[hIndex].func; - preHookFunc(sd, g); + preHookFunc(&sd, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14254,11 +14306,11 @@ void HP_clif_guild_invite(struct map_session_data *sd, struct guild *g) { void HP_clif_guild_inviteack(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_inviteack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_inviteack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_inviteack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14269,10 +14321,10 @@ void HP_clif_guild_inviteack(struct map_session_data *sd, int flag) { HPMHooks.source.clif.guild_inviteack(sd, flag); } if( HPMHooks.count.HP_clif_guild_inviteack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_inviteack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_inviteack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -14280,11 +14332,11 @@ void HP_clif_guild_inviteack(struct map_session_data *sd, int flag) { void HP_clif_guild_leave(struct map_session_data *sd, const char *name, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_leave_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name, const char *mes); + void (*preHookFunc) (struct map_session_data **sd, const char **name, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_leave_pre[hIndex].func; - preHookFunc(sd, name, mes); + preHookFunc(&sd, &name, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14306,11 +14358,11 @@ void HP_clif_guild_leave(struct map_session_data *sd, const char *name, const ch void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, const char *mes, int account_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_expulsion_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int *account_id); + void (*preHookFunc) (struct map_session_data **sd, const char **name, const char **mes, int *account_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_expulsion_pre[hIndex].func; - preHookFunc(sd, name, mes, &account_id); + preHookFunc(&sd, &name, &mes, &account_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14321,10 +14373,10 @@ void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, cons HPMHooks.source.clif.guild_expulsion(sd, name, mes, account_id); } if( HPMHooks.count.HP_clif_guild_expulsion_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int *account_id); + void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_expulsion_post[hIndex].func; - postHookFunc(sd, name, mes, &account_id); + postHookFunc(sd, name, mes, account_id); } } return; @@ -14332,11 +14384,11 @@ void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, cons void HP_clif_guild_positionchanged(struct guild *g, int idx) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_positionchanged_pre ) { - void (*preHookFunc) (struct guild *g, int *idx); + void (*preHookFunc) (struct guild **g, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionchanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_positionchanged_pre[hIndex].func; - preHookFunc(g, &idx); + preHookFunc(&g, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14347,10 +14399,10 @@ void HP_clif_guild_positionchanged(struct guild *g, int idx) { HPMHooks.source.clif.guild_positionchanged(g, idx); } if( HPMHooks.count.HP_clif_guild_positionchanged_post ) { - void (*postHookFunc) (struct guild *g, int *idx); + void (*postHookFunc) (struct guild *g, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionchanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_positionchanged_post[hIndex].func; - postHookFunc(g, &idx); + postHookFunc(g, idx); } } return; @@ -14358,11 +14410,11 @@ void HP_clif_guild_positionchanged(struct guild *g, int idx) { void HP_clif_guild_memberpositionchanged(struct guild *g, int idx) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_memberpositionchanged_pre ) { - void (*preHookFunc) (struct guild *g, int *idx); + void (*preHookFunc) (struct guild **g, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberpositionchanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_memberpositionchanged_pre[hIndex].func; - preHookFunc(g, &idx); + preHookFunc(&g, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14373,10 +14425,10 @@ void HP_clif_guild_memberpositionchanged(struct guild *g, int idx) { HPMHooks.source.clif.guild_memberpositionchanged(g, idx); } if( HPMHooks.count.HP_clif_guild_memberpositionchanged_post ) { - void (*postHookFunc) (struct guild *g, int *idx); + void (*postHookFunc) (struct guild *g, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberpositionchanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_memberpositionchanged_post[hIndex].func; - postHookFunc(g, &idx); + postHookFunc(g, idx); } } return; @@ -14384,11 +14436,11 @@ void HP_clif_guild_memberpositionchanged(struct guild *g, int idx) { void HP_clif_guild_emblem(struct map_session_data *sd, struct guild *g) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_emblem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct guild *g); + void (*preHookFunc) (struct map_session_data **sd, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_emblem_pre[hIndex].func; - preHookFunc(sd, g); + preHookFunc(&sd, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14410,11 +14462,11 @@ void HP_clif_guild_emblem(struct map_session_data *sd, struct guild *g) { void HP_clif_guild_emblem_area(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_emblem_area_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_area_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_emblem_area_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14436,11 +14488,11 @@ void HP_clif_guild_emblem_area(struct block_list *bl) { void HP_clif_guild_notice(struct map_session_data *sd, struct guild *g) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_notice_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct guild *g); + void (*preHookFunc) (struct map_session_data **sd, struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_notice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_notice_pre[hIndex].func; - preHookFunc(sd, g); + preHookFunc(&sd, &g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14462,11 +14514,11 @@ void HP_clif_guild_notice(struct map_session_data *sd, struct guild *g) { void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int len) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_message_pre ) { - void (*preHookFunc) (struct guild *g, int *account_id, const char *mes, int *len); + void (*preHookFunc) (struct guild **g, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_message_pre[hIndex].func; - preHookFunc(g, &account_id, mes, &len); + preHookFunc(&g, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14477,10 +14529,10 @@ void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int HPMHooks.source.clif.guild_message(g, account_id, mes, len); } if( HPMHooks.count.HP_clif_guild_message_post ) { - void (*postHookFunc) (struct guild *g, int *account_id, const char *mes, int *len); + void (*postHookFunc) (struct guild *g, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_message_post[hIndex].func; - postHookFunc(g, &account_id, mes, &len); + postHookFunc(g, account_id, mes, len); } } return; @@ -14488,11 +14540,11 @@ void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_reqalliance_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *name); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_reqalliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_reqalliance_pre[hIndex].func; - preHookFunc(sd, &account_id, name); + preHookFunc(&sd, &account_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14503,10 +14555,10 @@ void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, cons HPMHooks.source.clif.guild_reqalliance(sd, account_id, name); } if( HPMHooks.count.HP_clif_guild_reqalliance_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, const char *name); + void (*postHookFunc) (struct map_session_data *sd, int account_id, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_reqalliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_reqalliance_post[hIndex].func; - postHookFunc(sd, &account_id, name); + postHookFunc(sd, account_id, name); } } return; @@ -14514,11 +14566,11 @@ void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, cons void HP_clif_guild_allianceack(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_allianceack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_allianceack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14529,10 +14581,10 @@ void HP_clif_guild_allianceack(struct map_session_data *sd, int flag) { HPMHooks.source.clif.guild_allianceack(sd, flag); } if( HPMHooks.count.HP_clif_guild_allianceack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_allianceack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -14540,11 +14592,11 @@ void HP_clif_guild_allianceack(struct map_session_data *sd, int flag) { void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_delalliance_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_delalliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_delalliance_pre[hIndex].func; - preHookFunc(sd, &guild_id, &flag); + preHookFunc(&sd, &guild_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14555,10 +14607,10 @@ void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int fl HPMHooks.source.clif.guild_delalliance(sd, guild_id, flag); } if( HPMHooks.count.HP_clif_guild_delalliance_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *guild_id, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_delalliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_delalliance_post[hIndex].func; - postHookFunc(sd, &guild_id, &flag); + postHookFunc(sd, guild_id, flag); } } return; @@ -14566,11 +14618,11 @@ void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int fl void HP_clif_guild_oppositionack(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_oppositionack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_oppositionack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_oppositionack_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14581,10 +14633,10 @@ void HP_clif_guild_oppositionack(struct map_session_data *sd, int flag) { HPMHooks.source.clif.guild_oppositionack(sd, flag); } if( HPMHooks.count.HP_clif_guild_oppositionack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_oppositionack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_oppositionack_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -14592,11 +14644,11 @@ void HP_clif_guild_oppositionack(struct map_session_data *sd, int flag) { void HP_clif_guild_broken(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_broken_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_broken_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_broken_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14607,10 +14659,10 @@ void HP_clif_guild_broken(struct map_session_data *sd, int flag) { HPMHooks.source.clif.guild_broken(sd, flag); } if( HPMHooks.count.HP_clif_guild_broken_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_broken_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -14618,11 +14670,11 @@ void HP_clif_guild_broken(struct map_session_data *sd, int flag) { void HP_clif_guild_xy(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_xy_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_xy_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14644,11 +14696,11 @@ void HP_clif_guild_xy(struct map_session_data *sd) { void HP_clif_guild_xy_single(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_xy_single_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_xy_single_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14659,10 +14711,10 @@ void HP_clif_guild_xy_single(int fd, struct map_session_data *sd) { HPMHooks.source.clif.guild_xy_single(fd, sd); } if( HPMHooks.count.HP_clif_guild_xy_single_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_guild_xy_single_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -14670,11 +14722,11 @@ void HP_clif_guild_xy_single(int fd, struct map_session_data *sd) { void HP_clif_guild_xy_remove(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_xy_remove_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_xy_remove_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14696,11 +14748,11 @@ void HP_clif_guild_xy_remove(struct map_session_data *sd) { void HP_clif_guild_positionnamelist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_positionnamelist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionnamelist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_positionnamelist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14722,11 +14774,11 @@ void HP_clif_guild_positionnamelist(struct map_session_data *sd) { void HP_clif_guild_positioninfolist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_positioninfolist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positioninfolist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_positioninfolist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14748,11 +14800,11 @@ void HP_clif_guild_positioninfolist(struct map_session_data *sd) { void HP_clif_guild_expulsionlist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_guild_expulsionlist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsionlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_guild_expulsionlist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14775,11 +14827,11 @@ bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_clif_validate_emblem_pre ) { - bool (*preHookFunc) (const uint8 *emblem, unsigned long *emblem_len); + bool (*preHookFunc) (const uint8 **emblem, unsigned long *emblem_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_validate_emblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_validate_emblem_pre[hIndex].func; - retVal___ = preHookFunc(emblem, &emblem_len); + retVal___ = preHookFunc(&emblem, &emblem_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14790,10 +14842,10 @@ bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) { retVal___ = HPMHooks.source.clif.validate_emblem(emblem, emblem_len); } if( HPMHooks.count.HP_clif_validate_emblem_post ) { - bool (*postHookFunc) (bool retVal___, const uint8 *emblem, unsigned long *emblem_len); + bool (*postHookFunc) (bool retVal___, const uint8 *emblem, unsigned long emblem_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_validate_emblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_validate_emblem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, emblem, &emblem_len); + retVal___ = postHookFunc(retVal___, emblem, emblem_len); } } return retVal___; @@ -14801,11 +14853,11 @@ bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) { void HP_clif_bg_hp(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_bg_hp_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_hp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bg_hp_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14827,11 +14879,11 @@ void HP_clif_bg_hp(struct map_session_data *sd) { void HP_clif_bg_xy(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_bg_xy_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bg_xy_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14853,11 +14905,11 @@ void HP_clif_bg_xy(struct map_session_data *sd) { void HP_clif_bg_xy_remove(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_bg_xy_remove_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bg_xy_remove_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14876,14 +14928,14 @@ void HP_clif_bg_xy_remove(struct map_session_data *sd) { } return; } -void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes, size_t len) { +void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes) { int hIndex = 0; if( HPMHooks.count.HP_clif_bg_message_pre ) { - void (*preHookFunc) (struct battleground_data *bgd, int *src_id, const char *name, const char *mes, size_t *len); + void (*preHookFunc) (struct battleground_data **bgd, int *src_id, const char **name, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bg_message_pre[hIndex].func; - preHookFunc(bgd, &src_id, name, mes, &len); + preHookFunc(&bgd, &src_id, &name, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14891,13 +14943,13 @@ void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *n } } { - HPMHooks.source.clif.bg_message(bgd, src_id, name, mes, len); + HPMHooks.source.clif.bg_message(bgd, src_id, name, mes); } if( HPMHooks.count.HP_clif_bg_message_post ) { - void (*postHookFunc) (struct battleground_data *bgd, int *src_id, const char *name, const char *mes, size_t *len); + void (*postHookFunc) (struct battleground_data *bgd, int src_id, const char *name, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bg_message_post[hIndex].func; - postHookFunc(bgd, &src_id, name, mes, &len); + postHookFunc(bgd, src_id, name, mes); } } return; @@ -14920,10 +14972,10 @@ void HP_clif_bg_updatescore(int16 m) { HPMHooks.source.clif.bg_updatescore(m); } if( HPMHooks.count.HP_clif_bg_updatescore_post ) { - void (*postHookFunc) (int16 *m); + void (*postHookFunc) (int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bg_updatescore_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -14931,11 +14983,11 @@ void HP_clif_bg_updatescore(int16 m) { void HP_clif_bg_updatescore_single(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_bg_updatescore_single_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bg_updatescore_single_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14957,11 +15009,11 @@ void HP_clif_bg_updatescore_single(struct map_session_data *sd) { void HP_clif_sendbgemblem_area(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_sendbgemblem_area_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_area_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sendbgemblem_area_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14983,11 +15035,11 @@ void HP_clif_sendbgemblem_area(struct map_session_data *sd) { void HP_clif_sendbgemblem_single(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_sendbgemblem_single_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sendbgemblem_single_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -14998,10 +15050,10 @@ void HP_clif_sendbgemblem_single(int fd, struct map_session_data *sd) { HPMHooks.source.clif.sendbgemblem_single(fd, sd); } if( HPMHooks.count.HP_clif_sendbgemblem_single_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_sendbgemblem_single_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -15025,10 +15077,10 @@ int HP_clif_instance(int instance_id, int type, int flag) { retVal___ = HPMHooks.source.clif.instance(instance_id, type, flag); } if( HPMHooks.count.HP_clif_instance_post ) { - int (*postHookFunc) (int retVal___, int *instance_id, int *type, int *flag); + int (*postHookFunc) (int retVal___, int instance_id, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_instance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &instance_id, &type, &flag); + retVal___ = postHookFunc(retVal___, instance_id, type, flag); } } return retVal___; @@ -15051,10 +15103,10 @@ void HP_clif_instance_join(int fd, int instance_id) { HPMHooks.source.clif.instance_join(fd, instance_id); } if( HPMHooks.count.HP_clif_instance_join_post ) { - void (*postHookFunc) (int *fd, int *instance_id); + void (*postHookFunc) (int fd, int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_join_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_instance_join_post[hIndex].func; - postHookFunc(&fd, &instance_id); + postHookFunc(fd, instance_id); } } return; @@ -15077,10 +15129,10 @@ void HP_clif_instance_leave(int fd) { HPMHooks.source.clif.instance_leave(fd); } if( HPMHooks.count.HP_clif_instance_leave_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_instance_leave_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -15088,11 +15140,11 @@ void HP_clif_instance_leave(int fd) { void HP_clif_catch_process(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_catch_process_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_catch_process_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_catch_process_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15114,11 +15166,11 @@ void HP_clif_catch_process(struct map_session_data *sd) { void HP_clif_pet_roulette(struct map_session_data *sd, int data) { int hIndex = 0; if( HPMHooks.count.HP_clif_pet_roulette_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *data); + void (*preHookFunc) (struct map_session_data **sd, int *data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_roulette_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pet_roulette_pre[hIndex].func; - preHookFunc(sd, &data); + preHookFunc(&sd, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15129,10 +15181,10 @@ void HP_clif_pet_roulette(struct map_session_data *sd, int data) { HPMHooks.source.clif.pet_roulette(sd, data); } if( HPMHooks.count.HP_clif_pet_roulette_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *data); + void (*postHookFunc) (struct map_session_data *sd, int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_roulette_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pet_roulette_post[hIndex].func; - postHookFunc(sd, &data); + postHookFunc(sd, data); } } return; @@ -15140,11 +15192,11 @@ void HP_clif_pet_roulette(struct map_session_data *sd, int data) { void HP_clif_sendegg(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_sendegg_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendegg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_sendegg_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15166,11 +15218,11 @@ void HP_clif_sendegg(struct map_session_data *sd) { void HP_clif_send_petstatus(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_send_petstatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petstatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_send_petstatus_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15192,11 +15244,11 @@ void HP_clif_send_petstatus(struct map_session_data *sd) { void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int type, int param) { int hIndex = 0; if( HPMHooks.count.HP_clif_send_petdata_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd, int *type, int *param); + void (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd, int *type, int *param); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_send_petdata_pre[hIndex].func; - preHookFunc(sd, pd, &type, ¶m); + preHookFunc(&sd, &pd, &type, ¶m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15207,10 +15259,10 @@ void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int HPMHooks.source.clif.send_petdata(sd, pd, type, param); } if( HPMHooks.count.HP_clif_send_petdata_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct pet_data *pd, int *type, int *param); + void (*postHookFunc) (struct map_session_data *sd, struct pet_data *pd, int type, int param); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_send_petdata_post[hIndex].func; - postHookFunc(sd, pd, &type, ¶m); + postHookFunc(sd, pd, type, param); } } return; @@ -15218,11 +15270,11 @@ void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int void HP_clif_pet_emotion(struct pet_data *pd, int param) { int hIndex = 0; if( HPMHooks.count.HP_clif_pet_emotion_pre ) { - void (*preHookFunc) (struct pet_data *pd, int *param); + void (*preHookFunc) (struct pet_data **pd, int *param); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_emotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pet_emotion_pre[hIndex].func; - preHookFunc(pd, ¶m); + preHookFunc(&pd, ¶m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15233,10 +15285,10 @@ void HP_clif_pet_emotion(struct pet_data *pd, int param) { HPMHooks.source.clif.pet_emotion(pd, param); } if( HPMHooks.count.HP_clif_pet_emotion_post ) { - void (*postHookFunc) (struct pet_data *pd, int *param); + void (*postHookFunc) (struct pet_data *pd, int param); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_emotion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pet_emotion_post[hIndex].func; - postHookFunc(pd, ¶m); + postHookFunc(pd, param); } } return; @@ -15244,11 +15296,11 @@ void HP_clif_pet_emotion(struct pet_data *pd, int param) { void HP_clif_pet_food(struct map_session_data *sd, int foodid, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_pet_food_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *foodid, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *foodid, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_food_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pet_food_pre[hIndex].func; - preHookFunc(sd, &foodid, &fail); + preHookFunc(&sd, &foodid, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15259,10 +15311,10 @@ void HP_clif_pet_food(struct map_session_data *sd, int foodid, int fail) { HPMHooks.source.clif.pet_food(sd, foodid, fail); } if( HPMHooks.count.HP_clif_pet_food_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *foodid, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int foodid, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_food_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pet_food_post[hIndex].func; - postHookFunc(sd, &foodid, &fail); + postHookFunc(sd, foodid, fail); } } return; @@ -15271,12 +15323,12 @@ int HP_clif_friendslist_toggle_sub(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_friendslist_toggle_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -15303,11 +15355,11 @@ int HP_clif_friendslist_toggle_sub(struct map_session_data *sd, va_list ap) { void HP_clif_friendslist_send(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_friendslist_send_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_friendslist_send_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15329,11 +15381,11 @@ void HP_clif_friendslist_send(struct map_session_data *sd) { void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_data *f_sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_friendslist_reqack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **f_sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_reqack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_friendslist_reqack_pre[hIndex].func; - preHookFunc(sd, f_sd, &type); + preHookFunc(&sd, &f_sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15344,10 +15396,10 @@ void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_ HPMHooks.source.clif.friendslist_reqack(sd, f_sd, type); } if( HPMHooks.count.HP_clif_friendslist_reqack_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_reqack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_friendslist_reqack_post[hIndex].func; - postHookFunc(sd, f_sd, &type); + postHookFunc(sd, f_sd, type); } } return; @@ -15355,11 +15407,11 @@ void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_ void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int char_id, int online) { int hIndex = 0; if( HPMHooks.count.HP_clif_friendslist_toggle_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *online); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *char_id, int *online); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_pre[hIndex].func; - preHookFunc(sd, &account_id, &char_id, &online); + preHookFunc(&sd, &account_id, &char_id, &online); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15370,10 +15422,10 @@ void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int HPMHooks.source.clif.friendslist_toggle(sd, account_id, char_id, online); } if( HPMHooks.count.HP_clif_friendslist_toggle_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *online); + void (*postHookFunc) (struct map_session_data *sd, int account_id, int char_id, int online); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_post[hIndex].func; - postHookFunc(sd, &account_id, &char_id, &online); + postHookFunc(sd, account_id, char_id, online); } } return; @@ -15381,11 +15433,11 @@ void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int char_id, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_friendlist_req_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, const char *name); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *char_id, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendlist_req_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_friendlist_req_pre[hIndex].func; - preHookFunc(sd, &account_id, &char_id, name); + preHookFunc(&sd, &account_id, &char_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15396,10 +15448,10 @@ void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int cha HPMHooks.source.clif.friendlist_req(sd, account_id, char_id, name); } if( HPMHooks.count.HP_clif_friendlist_req_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, const char *name); + void (*postHookFunc) (struct map_session_data *sd, int account_id, int char_id, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendlist_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_friendlist_req_post[hIndex].func; - postHookFunc(sd, &account_id, &char_id, name); + postHookFunc(sd, account_id, char_id, name); } } return; @@ -15407,11 +15459,11 @@ void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int cha void HP_clif_GM_kickack(struct map_session_data *sd, int result) { int hIndex = 0; if( HPMHooks.count.HP_clif_GM_kickack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *result); + void (*preHookFunc) (struct map_session_data **sd, int *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kickack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_GM_kickack_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15422,10 +15474,10 @@ void HP_clif_GM_kickack(struct map_session_data *sd, int result) { HPMHooks.source.clif.GM_kickack(sd, result); } if( HPMHooks.count.HP_clif_GM_kickack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *result); + void (*postHookFunc) (struct map_session_data *sd, int result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kickack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_GM_kickack_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -15433,11 +15485,11 @@ void HP_clif_GM_kickack(struct map_session_data *sd, int result) { void HP_clif_GM_kick(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; if( HPMHooks.count.HP_clif_GM_kick_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_GM_kick_pre[hIndex].func; - preHookFunc(sd, tsd); + preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15459,11 +15511,11 @@ void HP_clif_GM_kick(struct map_session_data *sd, struct map_session_data *tsd) void HP_clif_manner_message(struct map_session_data *sd, uint32 type) { int hIndex = 0; if( HPMHooks.count.HP_clif_manner_message_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint32 *type); + void (*preHookFunc) (struct map_session_data **sd, uint32 *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_manner_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_manner_message_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15474,10 +15526,10 @@ void HP_clif_manner_message(struct map_session_data *sd, uint32 type) { HPMHooks.source.clif.manner_message(sd, type); } if( HPMHooks.count.HP_clif_manner_message_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint32 *type); + void (*postHookFunc) (struct map_session_data *sd, uint32 type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_manner_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_manner_message_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -15485,11 +15537,11 @@ void HP_clif_manner_message(struct map_session_data *sd, uint32 type) { void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *tsd, uint8 type) { int hIndex = 0; if( HPMHooks.count.HP_clif_GM_silence_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 *type); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd, uint8 *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_silence_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_GM_silence_pre[hIndex].func; - preHookFunc(sd, tsd, &type); + preHookFunc(&sd, &tsd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15500,10 +15552,10 @@ void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *ts HPMHooks.source.clif.GM_silence(sd, tsd, type); } if( HPMHooks.count.HP_clif_GM_silence_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 *type); + void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_silence_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_GM_silence_post[hIndex].func; - postHookFunc(sd, tsd, &type); + postHookFunc(sd, tsd, type); } } return; @@ -15511,11 +15563,11 @@ void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *ts void HP_clif_account_name(struct map_session_data *sd, int account_id, const char *accname) { int hIndex = 0; if( HPMHooks.count.HP_clif_account_name_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *accname); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, const char **accname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_account_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_account_name_pre[hIndex].func; - preHookFunc(sd, &account_id, accname); + preHookFunc(&sd, &account_id, &accname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15526,10 +15578,10 @@ void HP_clif_account_name(struct map_session_data *sd, int account_id, const cha HPMHooks.source.clif.account_name(sd, account_id, accname); } if( HPMHooks.count.HP_clif_account_name_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, const char *accname); + void (*postHookFunc) (struct map_session_data *sd, int account_id, const char *accname); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_account_name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_account_name_post[hIndex].func; - postHookFunc(sd, &account_id, accname); + postHookFunc(sd, account_id, accname); } } return; @@ -15537,11 +15589,11 @@ void HP_clif_account_name(struct map_session_data *sd, int account_id, const cha void HP_clif_check(int fd, struct map_session_data *pl_sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_check_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *pl_sd); + void (*preHookFunc) (int *fd, struct map_session_data **pl_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_check_pre[hIndex].func; - preHookFunc(&fd, pl_sd); + preHookFunc(&fd, &pl_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15552,10 +15604,10 @@ void HP_clif_check(int fd, struct map_session_data *pl_sd) { HPMHooks.source.clif.check(fd, pl_sd); } if( HPMHooks.count.HP_clif_check_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *pl_sd); + void (*postHookFunc) (int fd, struct map_session_data *pl_sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_check_post[hIndex].func; - postHookFunc(&fd, pl_sd); + postHookFunc(fd, pl_sd); } } return; @@ -15563,11 +15615,11 @@ void HP_clif_check(int fd, struct map_session_data *pl_sd) { void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_hominfo_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, struct homun_data **hd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_hominfo_pre[hIndex].func; - preHookFunc(sd, hd, &flag); + preHookFunc(&sd, &hd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15578,10 +15630,10 @@ void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int fla HPMHooks.source.clif.hominfo(sd, hd, flag); } if( HPMHooks.count.HP_clif_hominfo_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct homun_data *hd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, struct homun_data *hd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_hominfo_post[hIndex].func; - postHookFunc(sd, hd, &flag); + postHookFunc(sd, hd, flag); } } return; @@ -15589,11 +15641,11 @@ void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int fla void HP_clif_homskillinfoblock(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_homskillinfoblock_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillinfoblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_homskillinfoblock_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15615,11 +15667,11 @@ void HP_clif_homskillinfoblock(struct map_session_data *sd) { void HP_clif_homskillup(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_homskillup_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_homskillup_pre[hIndex].func; - preHookFunc(sd, &skill_id); + preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15630,10 +15682,10 @@ void HP_clif_homskillup(struct map_session_data *sd, uint16 skill_id) { HPMHooks.source.clif.homskillup(sd, skill_id); } if( HPMHooks.count.HP_clif_homskillup_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_homskillup_post[hIndex].func; - postHookFunc(sd, &skill_id); + postHookFunc(sd, skill_id); } } return; @@ -15641,11 +15693,11 @@ void HP_clif_homskillup(struct map_session_data *sd, uint16 skill_id) { void HP_clif_hom_food(struct map_session_data *sd, int foodid, int fail) { int hIndex = 0; if( HPMHooks.count.HP_clif_hom_food_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *foodid, int *fail); + void (*preHookFunc) (struct map_session_data **sd, int *foodid, int *fail); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_hom_food_pre[hIndex].func; - preHookFunc(sd, &foodid, &fail); + preHookFunc(&sd, &foodid, &fail); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15656,10 +15708,10 @@ void HP_clif_hom_food(struct map_session_data *sd, int foodid, int fail) { HPMHooks.source.clif.hom_food(sd, foodid, fail); } if( HPMHooks.count.HP_clif_hom_food_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *foodid, int *fail); + void (*postHookFunc) (struct map_session_data *sd, int foodid, int fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_hom_food_post[hIndex].func; - postHookFunc(sd, &foodid, &fail); + postHookFunc(sd, foodid, fail); } } return; @@ -15667,11 +15719,11 @@ void HP_clif_hom_food(struct map_session_data *sd, int foodid, int fail) { void HP_clif_send_homdata(struct map_session_data *sd, int state, int param) { int hIndex = 0; if( HPMHooks.count.HP_clif_send_homdata_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *state, int *param); + void (*preHookFunc) (struct map_session_data **sd, int *state, int *param); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_homdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_send_homdata_pre[hIndex].func; - preHookFunc(sd, &state, ¶m); + preHookFunc(&sd, &state, ¶m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15682,10 +15734,10 @@ void HP_clif_send_homdata(struct map_session_data *sd, int state, int param) { HPMHooks.source.clif.send_homdata(sd, state, param); } if( HPMHooks.count.HP_clif_send_homdata_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *state, int *param); + void (*postHookFunc) (struct map_session_data *sd, int state, int param); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_homdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_send_homdata_post[hIndex].func; - postHookFunc(sd, &state, ¶m); + postHookFunc(sd, state, param); } } return; @@ -15693,11 +15745,11 @@ void HP_clif_send_homdata(struct map_session_data *sd, int state, int param) { void HP_clif_quest_send_list(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_send_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_send_list_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15719,11 +15771,11 @@ void HP_clif_quest_send_list(struct map_session_data *sd) { void HP_clif_quest_send_mission(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_send_mission_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_mission_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_send_mission_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15745,11 +15797,11 @@ void HP_clif_quest_send_mission(struct map_session_data *sd) { void HP_clif_quest_add(struct map_session_data *sd, struct quest *qd) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_add_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct quest *qd); + void (*preHookFunc) (struct map_session_data **sd, struct quest **qd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_add_pre[hIndex].func; - preHookFunc(sd, qd); + preHookFunc(&sd, &qd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15771,11 +15823,11 @@ void HP_clif_quest_add(struct map_session_data *sd, struct quest *qd) { void HP_clif_quest_delete(struct map_session_data *sd, int quest_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_delete_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *quest_id); + void (*preHookFunc) (struct map_session_data **sd, int *quest_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_delete_pre[hIndex].func; - preHookFunc(sd, &quest_id); + preHookFunc(&sd, &quest_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15786,10 +15838,10 @@ void HP_clif_quest_delete(struct map_session_data *sd, int quest_id) { HPMHooks.source.clif.quest_delete(sd, quest_id); } if( HPMHooks.count.HP_clif_quest_delete_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *quest_id); + void (*postHookFunc) (struct map_session_data *sd, int quest_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_quest_delete_post[hIndex].func; - postHookFunc(sd, &quest_id); + postHookFunc(sd, quest_id); } } return; @@ -15797,11 +15849,11 @@ void HP_clif_quest_delete(struct map_session_data *sd, int quest_id) { void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool active) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_update_status_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *quest_id, bool *active); + void (*preHookFunc) (struct map_session_data **sd, int *quest_id, bool *active); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_update_status_pre[hIndex].func; - preHookFunc(sd, &quest_id, &active); + preHookFunc(&sd, &quest_id, &active); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15812,10 +15864,10 @@ void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool HPMHooks.source.clif.quest_update_status(sd, quest_id, active); } if( HPMHooks.count.HP_clif_quest_update_status_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *quest_id, bool *active); + void (*postHookFunc) (struct map_session_data *sd, int quest_id, bool active); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_status_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_quest_update_status_post[hIndex].func; - postHookFunc(sd, &quest_id, &active); + postHookFunc(sd, quest_id, active); } } return; @@ -15823,11 +15875,11 @@ void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool void HP_clif_quest_update_objective(struct map_session_data *sd, struct quest *qd) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_update_objective_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct quest *qd); + void (*preHookFunc) (struct map_session_data **sd, struct quest **qd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_objective_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_update_objective_pre[hIndex].func; - preHookFunc(sd, qd); + preHookFunc(&sd, &qd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15849,11 +15901,11 @@ void HP_clif_quest_update_objective(struct map_session_data *sd, struct quest *q void HP_clif_quest_show_event(struct map_session_data *sd, struct block_list *bl, short state, short color) { int hIndex = 0; if( HPMHooks.count.HP_clif_quest_show_event_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, short *state, short *color); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, short *state, short *color); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_show_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_quest_show_event_pre[hIndex].func; - preHookFunc(sd, bl, &state, &color); + preHookFunc(&sd, &bl, &state, &color); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15864,10 +15916,10 @@ void HP_clif_quest_show_event(struct map_session_data *sd, struct block_list *bl HPMHooks.source.clif.quest_show_event(sd, bl, state, color); } if( HPMHooks.count.HP_clif_quest_show_event_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, short *state, short *color); + void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, short state, short color); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_show_event_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_quest_show_event_post[hIndex].func; - postHookFunc(sd, bl, &state, &color); + postHookFunc(sd, bl, state, color); } } return; @@ -15890,10 +15942,10 @@ void HP_clif_mail_window(int fd, int flag) { HPMHooks.source.clif.mail_window(fd, flag); } if( HPMHooks.count.HP_clif_mail_window_post ) { - void (*postHookFunc) (int *fd, int *flag); + void (*postHookFunc) (int fd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_window_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_window_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -15901,11 +15953,11 @@ void HP_clif_mail_window(int fd, int flag) { void HP_clif_mail_read(struct map_session_data *sd, int mail_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_mail_read_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *mail_id); + void (*preHookFunc) (struct map_session_data **sd, int *mail_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mail_read_pre[hIndex].func; - preHookFunc(sd, &mail_id); + preHookFunc(&sd, &mail_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -15916,10 +15968,10 @@ void HP_clif_mail_read(struct map_session_data *sd, int mail_id) { HPMHooks.source.clif.mail_read(sd, mail_id); } if( HPMHooks.count.HP_clif_mail_read_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *mail_id); + void (*postHookFunc) (struct map_session_data *sd, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_read_post[hIndex].func; - postHookFunc(sd, &mail_id); + postHookFunc(sd, mail_id); } } return; @@ -15942,10 +15994,10 @@ void HP_clif_mail_delete(int fd, int mail_id, short fail) { HPMHooks.source.clif.mail_delete(fd, mail_id, fail); } if( HPMHooks.count.HP_clif_mail_delete_post ) { - void (*postHookFunc) (int *fd, int *mail_id, short *fail); + void (*postHookFunc) (int fd, int mail_id, short fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_delete_post[hIndex].func; - postHookFunc(&fd, &mail_id, &fail); + postHookFunc(fd, mail_id, fail); } } return; @@ -15968,10 +16020,10 @@ void HP_clif_mail_return(int fd, int mail_id, short fail) { HPMHooks.source.clif.mail_return(fd, mail_id, fail); } if( HPMHooks.count.HP_clif_mail_return_post ) { - void (*postHookFunc) (int *fd, int *mail_id, short *fail); + void (*postHookFunc) (int fd, int mail_id, short fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_return_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_return_post[hIndex].func; - postHookFunc(&fd, &mail_id, &fail); + postHookFunc(fd, mail_id, fail); } } return; @@ -15994,10 +16046,10 @@ void HP_clif_mail_send(int fd, bool fail) { HPMHooks.source.clif.mail_send(fd, fail); } if( HPMHooks.count.HP_clif_mail_send_post ) { - void (*postHookFunc) (int *fd, bool *fail); + void (*postHookFunc) (int fd, bool fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_send_post[hIndex].func; - postHookFunc(&fd, &fail); + postHookFunc(fd, fail); } } return; @@ -16005,11 +16057,11 @@ void HP_clif_mail_send(int fd, bool fail) { void HP_clif_mail_new(int fd, int mail_id, const char *sender, const char *title) { int hIndex = 0; if( HPMHooks.count.HP_clif_mail_new_pre ) { - void (*preHookFunc) (int *fd, int *mail_id, const char *sender, const char *title); + void (*preHookFunc) (int *fd, int *mail_id, const char **sender, const char **title); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_new_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mail_new_pre[hIndex].func; - preHookFunc(&fd, &mail_id, sender, title); + preHookFunc(&fd, &mail_id, &sender, &title); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16020,10 +16072,10 @@ void HP_clif_mail_new(int fd, int mail_id, const char *sender, const char *title HPMHooks.source.clif.mail_new(fd, mail_id, sender, title); } if( HPMHooks.count.HP_clif_mail_new_post ) { - void (*postHookFunc) (int *fd, int *mail_id, const char *sender, const char *title); + void (*postHookFunc) (int fd, int mail_id, const char *sender, const char *title); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_new_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_new_post[hIndex].func; - postHookFunc(&fd, &mail_id, sender, title); + postHookFunc(fd, mail_id, sender, title); } } return; @@ -16031,11 +16083,11 @@ void HP_clif_mail_new(int fd, int mail_id, const char *sender, const char *title void HP_clif_mail_refreshinbox(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_mail_refreshinbox_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_refreshinbox_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mail_refreshinbox_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16072,10 +16124,10 @@ void HP_clif_mail_getattachment(int fd, uint8 flag) { HPMHooks.source.clif.mail_getattachment(fd, flag); } if( HPMHooks.count.HP_clif_mail_getattachment_post ) { - void (*postHookFunc) (int *fd, uint8 *flag); + void (*postHookFunc) (int fd, uint8 flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_getattachment_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_getattachment_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -16098,10 +16150,10 @@ void HP_clif_mail_setattachment(int fd, int index, uint8 flag) { HPMHooks.source.clif.mail_setattachment(fd, index, flag); } if( HPMHooks.count.HP_clif_mail_setattachment_post ) { - void (*postHookFunc) (int *fd, int *index, uint8 *flag); + void (*postHookFunc) (int fd, int index, uint8 flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_setattachment_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mail_setattachment_post[hIndex].func; - postHookFunc(&fd, &index, &flag); + postHookFunc(fd, index, flag); } } return; @@ -16109,11 +16161,11 @@ void HP_clif_mail_setattachment(int fd, int index, uint8 flag) { void HP_clif_auction_openwindow(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_auction_openwindow_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_openwindow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_auction_openwindow_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16135,11 +16187,11 @@ void HP_clif_auction_openwindow(struct map_session_data *sd) { void HP_clif_auction_results(struct map_session_data *sd, short count, short pages, const uint8 *buf) { int hIndex = 0; if( HPMHooks.count.HP_clif_auction_results_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *count, short *pages, const uint8 *buf); + void (*preHookFunc) (struct map_session_data **sd, short *count, short *pages, const uint8 **buf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_results_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_auction_results_pre[hIndex].func; - preHookFunc(sd, &count, &pages, buf); + preHookFunc(&sd, &count, &pages, &buf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16150,10 +16202,10 @@ void HP_clif_auction_results(struct map_session_data *sd, short count, short pag HPMHooks.source.clif.auction_results(sd, count, pages, buf); } if( HPMHooks.count.HP_clif_auction_results_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *count, short *pages, const uint8 *buf); + void (*postHookFunc) (struct map_session_data *sd, short count, short pages, const uint8 *buf); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_results_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_auction_results_post[hIndex].func; - postHookFunc(sd, &count, &pages, buf); + postHookFunc(sd, count, pages, buf); } } return; @@ -16176,10 +16228,10 @@ void HP_clif_auction_message(int fd, unsigned char flag) { HPMHooks.source.clif.auction_message(fd, flag); } if( HPMHooks.count.HP_clif_auction_message_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_auction_message_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -16202,10 +16254,10 @@ void HP_clif_auction_close(int fd, unsigned char flag) { HPMHooks.source.clif.auction_close(fd, flag); } if( HPMHooks.count.HP_clif_auction_close_post ) { - void (*postHookFunc) (int *fd, unsigned char *flag); + void (*postHookFunc) (int fd, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_auction_close_post[hIndex].func; - postHookFunc(&fd, &flag); + postHookFunc(fd, flag); } } return; @@ -16228,10 +16280,10 @@ void HP_clif_auction_setitem(int fd, int index, bool fail) { HPMHooks.source.clif.auction_setitem(fd, index, fail); } if( HPMHooks.count.HP_clif_auction_setitem_post ) { - void (*postHookFunc) (int *fd, int *index, bool *fail); + void (*postHookFunc) (int fd, int index, bool fail); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_setitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_auction_setitem_post[hIndex].func; - postHookFunc(&fd, &index, &fail); + postHookFunc(fd, index, fail); } } return; @@ -16239,11 +16291,11 @@ void HP_clif_auction_setitem(int fd, int index, bool fail) { void HP_clif_mercenary_info(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_mercenary_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mercenary_info_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16265,11 +16317,11 @@ void HP_clif_mercenary_info(struct map_session_data *sd) { void HP_clif_mercenary_skillblock(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_mercenary_skillblock_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_skillblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mercenary_skillblock_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16291,11 +16343,11 @@ void HP_clif_mercenary_skillblock(struct map_session_data *sd) { void HP_clif_mercenary_message(struct map_session_data *sd, int message) { int hIndex = 0; if( HPMHooks.count.HP_clif_mercenary_message_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *message); + void (*preHookFunc) (struct map_session_data **sd, int *message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mercenary_message_pre[hIndex].func; - preHookFunc(sd, &message); + preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16306,10 +16358,10 @@ void HP_clif_mercenary_message(struct map_session_data *sd, int message) { HPMHooks.source.clif.mercenary_message(sd, message); } if( HPMHooks.count.HP_clif_mercenary_message_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *message); + void (*postHookFunc) (struct map_session_data *sd, int message); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mercenary_message_post[hIndex].func; - postHookFunc(sd, &message); + postHookFunc(sd, message); } } return; @@ -16317,11 +16369,11 @@ void HP_clif_mercenary_message(struct map_session_data *sd, int message) { void HP_clif_mercenary_updatestatus(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_mercenary_updatestatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_updatestatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_mercenary_updatestatus_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16332,10 +16384,10 @@ void HP_clif_mercenary_updatestatus(struct map_session_data *sd, int type) { HPMHooks.source.clif.mercenary_updatestatus(sd, type); } if( HPMHooks.count.HP_clif_mercenary_updatestatus_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_updatestatus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_mercenary_updatestatus_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -16358,10 +16410,10 @@ void HP_clif_rental_time(int fd, int nameid, int seconds) { HPMHooks.source.clif.rental_time(fd, nameid, seconds); } if( HPMHooks.count.HP_clif_rental_time_post ) { - void (*postHookFunc) (int *fd, int *nameid, int *seconds); + void (*postHookFunc) (int fd, int nameid, int seconds); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_time_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_rental_time_post[hIndex].func; - postHookFunc(&fd, &nameid, &seconds); + postHookFunc(fd, nameid, seconds); } } return; @@ -16384,10 +16436,10 @@ void HP_clif_rental_expired(int fd, int index, int nameid) { HPMHooks.source.clif.rental_expired(fd, index, nameid); } if( HPMHooks.count.HP_clif_rental_expired_post ) { - void (*postHookFunc) (int *fd, int *index, int *nameid); + void (*postHookFunc) (int fd, int index, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_expired_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_rental_expired_post[hIndex].func; - postHookFunc(&fd, &index, &nameid); + postHookFunc(fd, index, nameid); } } return; @@ -16395,11 +16447,11 @@ void HP_clif_rental_expired(int fd, int index, int nameid) { void HP_clif_PartyBookingRegisterAck(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16410,10 +16462,10 @@ void HP_clif_PartyBookingRegisterAck(struct map_session_data *sd, int flag) { HPMHooks.source.clif.PartyBookingRegisterAck(sd, flag); } if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -16421,11 +16473,11 @@ void HP_clif_PartyBookingRegisterAck(struct map_session_data *sd, int flag) { void HP_clif_PartyBookingDeleteAck(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16436,10 +16488,10 @@ void HP_clif_PartyBookingDeleteAck(struct map_session_data *sd, int flag) { HPMHooks.source.clif.PartyBookingDeleteAck(sd, flag); } if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -16447,11 +16499,11 @@ void HP_clif_PartyBookingDeleteAck(struct map_session_data *sd, int flag) { void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **results, int count, bool more_result) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingSearchAck_pre ) { - void (*preHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result); + void (*preHookFunc) (int *fd, struct party_booking_ad_info ***results, int *count, bool *more_result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSearchAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingSearchAck_pre[hIndex].func; - preHookFunc(&fd, results, &count, &more_result); + preHookFunc(&fd, &results, &count, &more_result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16462,10 +16514,10 @@ void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **result HPMHooks.source.clif.PartyBookingSearchAck(fd, results, count, more_result); } if( HPMHooks.count.HP_clif_PartyBookingSearchAck_post ) { - void (*postHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result); + void (*postHookFunc) (int fd, struct party_booking_ad_info **results, int count, bool more_result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSearchAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingSearchAck_post[hIndex].func; - postHookFunc(&fd, results, &count, &more_result); + postHookFunc(fd, results, count, more_result); } } return; @@ -16473,11 +16525,11 @@ void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **result void HP_clif_PartyBookingUpdateNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); + void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingUpdateNotify_pre[hIndex].func; - preHookFunc(sd, pb_ad); + preHookFunc(&sd, &pb_ad); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16499,11 +16551,11 @@ void HP_clif_PartyBookingUpdateNotify(struct map_session_data *sd, struct party_ void HP_clif_PartyBookingDeleteNotify(struct map_session_data *sd, int index) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index); + void (*preHookFunc) (struct map_session_data **sd, int *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_pre[hIndex].func; - preHookFunc(sd, &index); + preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16514,10 +16566,10 @@ void HP_clif_PartyBookingDeleteNotify(struct map_session_data *sd, int index) { HPMHooks.source.clif.PartyBookingDeleteNotify(sd, index); } if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index); + void (*postHookFunc) (struct map_session_data *sd, int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_post[hIndex].func; - postHookFunc(sd, &index); + postHookFunc(sd, index); } } return; @@ -16525,11 +16577,11 @@ void HP_clif_PartyBookingDeleteNotify(struct map_session_data *sd, int index) { void HP_clif_PartyBookingInsertNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); + void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingInsertNotify_pre[hIndex].func; - preHookFunc(sd, pb_ad); + preHookFunc(&sd, &pb_ad); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16551,11 +16603,11 @@ void HP_clif_PartyBookingInsertNotify(struct map_session_data *sd, struct party_ void HP_clif_PartyRecruitRegisterAck(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitRegisterAck_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitRegisterAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitRegisterAck_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16566,10 +16618,10 @@ void HP_clif_PartyRecruitRegisterAck(struct map_session_data *sd, int flag) { HPMHooks.source.clif.PartyRecruitRegisterAck(sd, flag); } if( HPMHooks.count.HP_clif_PartyRecruitRegisterAck_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitRegisterAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyRecruitRegisterAck_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -16577,11 +16629,11 @@ void HP_clif_PartyRecruitRegisterAck(struct map_session_data *sd, int flag) { void HP_clif_PartyRecruitDeleteAck(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitDeleteAck_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteAck_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16592,10 +16644,10 @@ void HP_clif_PartyRecruitDeleteAck(struct map_session_data *sd, int flag) { HPMHooks.source.clif.PartyRecruitDeleteAck(sd, flag); } if( HPMHooks.count.HP_clif_PartyRecruitDeleteAck_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteAck_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -16603,11 +16655,11 @@ void HP_clif_PartyRecruitDeleteAck(struct map_session_data *sd, int flag) { void HP_clif_PartyRecruitSearchAck(int fd, struct party_booking_ad_info **results, int count, bool more_result) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitSearchAck_pre ) { - void (*preHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result); + void (*preHookFunc) (int *fd, struct party_booking_ad_info ***results, int *count, bool *more_result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitSearchAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitSearchAck_pre[hIndex].func; - preHookFunc(&fd, results, &count, &more_result); + preHookFunc(&fd, &results, &count, &more_result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16618,10 +16670,10 @@ void HP_clif_PartyRecruitSearchAck(int fd, struct party_booking_ad_info **result HPMHooks.source.clif.PartyRecruitSearchAck(fd, results, count, more_result); } if( HPMHooks.count.HP_clif_PartyRecruitSearchAck_post ) { - void (*postHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result); + void (*postHookFunc) (int fd, struct party_booking_ad_info **results, int count, bool more_result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitSearchAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyRecruitSearchAck_post[hIndex].func; - postHookFunc(&fd, results, &count, &more_result); + postHookFunc(fd, results, count, more_result); } } return; @@ -16629,11 +16681,11 @@ void HP_clif_PartyRecruitSearchAck(int fd, struct party_booking_ad_info **result void HP_clif_PartyRecruitUpdateNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); + void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitUpdateNotify_pre[hIndex].func; - preHookFunc(sd, pb_ad); + preHookFunc(&sd, &pb_ad); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16655,11 +16707,11 @@ void HP_clif_PartyRecruitUpdateNotify(struct map_session_data *sd, struct party_ void HP_clif_PartyRecruitDeleteNotify(struct map_session_data *sd, int index) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *index); + void (*preHookFunc) (struct map_session_data **sd, int *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteNotify_pre[hIndex].func; - preHookFunc(sd, &index); + preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16670,10 +16722,10 @@ void HP_clif_PartyRecruitDeleteNotify(struct map_session_data *sd, int index) { HPMHooks.source.clif.PartyRecruitDeleteNotify(sd, index); } if( HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *index); + void (*postHookFunc) (struct map_session_data *sd, int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteNotify_post[hIndex].func; - postHookFunc(sd, &index); + postHookFunc(sd, index); } } return; @@ -16681,11 +16733,11 @@ void HP_clif_PartyRecruitDeleteNotify(struct map_session_data *sd, int index) { void HP_clif_PartyRecruitInsertNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyRecruitInsertNotify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad); + void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitInsertNotify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyRecruitInsertNotify_pre[hIndex].func; - preHookFunc(sd, pb_ad); + preHookFunc(&sd, &pb_ad); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16707,11 +16759,11 @@ void HP_clif_PartyRecruitInsertNotify(struct map_session_data *sd, struct party_ void HP_clif_PartyBookingVolunteerInfo(int index, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre ) { - void (*preHookFunc) (int *index, struct map_session_data *sd); + void (*preHookFunc) (int *index, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_pre[hIndex].func; - preHookFunc(&index, sd); + preHookFunc(&index, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16722,10 +16774,10 @@ void HP_clif_PartyBookingVolunteerInfo(int index, struct map_session_data *sd) { HPMHooks.source.clif.PartyBookingVolunteerInfo(index, sd); } if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post ) { - void (*postHookFunc) (int *index, struct map_session_data *sd); + void (*postHookFunc) (int index, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_post[hIndex].func; - postHookFunc(&index, sd); + postHookFunc(index, sd); } } return; @@ -16733,11 +16785,11 @@ void HP_clif_PartyBookingVolunteerInfo(int index, struct map_session_data *sd) { void HP_clif_PartyBookingRefuseVolunteer(unsigned int aid, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre ) { - void (*preHookFunc) (unsigned int *aid, struct map_session_data *sd); + void (*preHookFunc) (unsigned int *aid, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_pre[hIndex].func; - preHookFunc(&aid, sd); + preHookFunc(&aid, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16748,10 +16800,10 @@ void HP_clif_PartyBookingRefuseVolunteer(unsigned int aid, struct map_session_da HPMHooks.source.clif.PartyBookingRefuseVolunteer(aid, sd); } if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post ) { - void (*postHookFunc) (unsigned int *aid, struct map_session_data *sd); + void (*postHookFunc) (unsigned int aid, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_post[hIndex].func; - postHookFunc(&aid, sd); + postHookFunc(aid, sd); } } return; @@ -16759,11 +16811,11 @@ void HP_clif_PartyBookingRefuseVolunteer(unsigned int aid, struct map_session_da void HP_clif_PartyBookingCancelVolunteer(int index, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre ) { - void (*preHookFunc) (int *index, struct map_session_data *sd); + void (*preHookFunc) (int *index, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_pre[hIndex].func; - preHookFunc(&index, sd); + preHookFunc(&index, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16774,10 +16826,10 @@ void HP_clif_PartyBookingCancelVolunteer(int index, struct map_session_data *sd) HPMHooks.source.clif.PartyBookingCancelVolunteer(index, sd); } if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post ) { - void (*postHookFunc) (int *index, struct map_session_data *sd); + void (*postHookFunc) (int index, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_post[hIndex].func; - postHookFunc(&index, sd); + postHookFunc(index, sd); } } return; @@ -16785,11 +16837,11 @@ void HP_clif_PartyBookingCancelVolunteer(int index, struct map_session_data *sd) void HP_clif_PartyBookingAddFilteringList(int index, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre ) { - void (*preHookFunc) (int *index, struct map_session_data *sd); + void (*preHookFunc) (int *index, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_pre[hIndex].func; - preHookFunc(&index, sd); + preHookFunc(&index, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16800,10 +16852,10 @@ void HP_clif_PartyBookingAddFilteringList(int index, struct map_session_data *sd HPMHooks.source.clif.PartyBookingAddFilteringList(index, sd); } if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post ) { - void (*postHookFunc) (int *index, struct map_session_data *sd); + void (*postHookFunc) (int index, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_post[hIndex].func; - postHookFunc(&index, sd); + postHookFunc(index, sd); } } return; @@ -16811,11 +16863,11 @@ void HP_clif_PartyBookingAddFilteringList(int index, struct map_session_data *sd void HP_clif_PartyBookingSubFilteringList(int gid, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre ) { - void (*preHookFunc) (int *gid, struct map_session_data *sd); + void (*preHookFunc) (int *gid, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_pre[hIndex].func; - preHookFunc(&gid, sd); + preHookFunc(&gid, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16826,10 +16878,10 @@ void HP_clif_PartyBookingSubFilteringList(int gid, struct map_session_data *sd) HPMHooks.source.clif.PartyBookingSubFilteringList(gid, sd); } if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post ) { - void (*postHookFunc) (int *gid, struct map_session_data *sd); + void (*postHookFunc) (int gid, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_post[hIndex].func; - postHookFunc(&gid, sd); + postHookFunc(gid, sd); } } return; @@ -16837,11 +16889,11 @@ void HP_clif_PartyBookingSubFilteringList(int gid, struct map_session_data *sd) void HP_clif_buyingstore_open(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_open_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_open_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16863,11 +16915,11 @@ void HP_clif_buyingstore_open(struct map_session_data *sd) { void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short result, unsigned int weight) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_open_failed_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *result, unsigned int *weight); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *result, unsigned int *weight); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_failed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_open_failed_pre[hIndex].func; - preHookFunc(sd, &result, &weight); + preHookFunc(&sd, &result, &weight); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16878,10 +16930,10 @@ void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short HPMHooks.source.clif.buyingstore_open_failed(sd, result, weight); } if( HPMHooks.count.HP_clif_buyingstore_open_failed_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *result, unsigned int *weight); + void (*postHookFunc) (struct map_session_data *sd, unsigned short result, unsigned int weight); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyingstore_open_failed_post[hIndex].func; - postHookFunc(sd, &result, &weight); + postHookFunc(sd, result, weight); } } return; @@ -16889,11 +16941,11 @@ void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short void HP_clif_buyingstore_myitemlist(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_myitemlist_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_myitemlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_myitemlist_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16915,11 +16967,11 @@ void HP_clif_buyingstore_myitemlist(struct map_session_data *sd) { void HP_clif_buyingstore_entry(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_entry_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16941,11 +16993,11 @@ void HP_clif_buyingstore_entry(struct map_session_data *sd) { void HP_clif_buyingstore_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_entry_single_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_single_pre[hIndex].func; - preHookFunc(sd, pl_sd); + preHookFunc(&sd, &pl_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16967,11 +17019,11 @@ void HP_clif_buyingstore_entry_single(struct map_session_data *sd, struct map_se void HP_clif_buyingstore_disappear_entry(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -16993,11 +17045,11 @@ void HP_clif_buyingstore_disappear_entry(struct map_session_data *sd) { void HP_clif_buyingstore_disappear_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_single_pre[hIndex].func; - preHookFunc(sd, pl_sd); + preHookFunc(&sd, &pl_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17019,11 +17071,11 @@ void HP_clif_buyingstore_disappear_entry_single(struct map_session_data *sd, str void HP_clif_buyingstore_itemlist(struct map_session_data *sd, struct map_session_data *pl_sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_itemlist_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_itemlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_itemlist_pre[hIndex].func; - preHookFunc(sd, pl_sd); + preHookFunc(&sd, &pl_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17045,11 +17097,11 @@ void HP_clif_buyingstore_itemlist(struct map_session_data *sd, struct map_sessio void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short result) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *result); + void (*preHookFunc) (struct map_session_data **sd, short *result); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_buyer_pre[hIndex].func; - preHookFunc(sd, &result); + preHookFunc(&sd, &result); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17060,10 +17112,10 @@ void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short r HPMHooks.source.clif.buyingstore_trade_failed_buyer(sd, result); } if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *result); + void (*postHookFunc) (struct map_session_data *sd, short result); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_buyer_post[hIndex].func; - postHookFunc(sd, &result); + postHookFunc(sd, result); } } return; @@ -17071,11 +17123,11 @@ void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short r void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short nameid, unsigned short amount) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_update_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *amount); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid, unsigned short *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_update_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_update_item_pre[hIndex].func; - preHookFunc(sd, &nameid, &amount); + preHookFunc(&sd, &nameid, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17086,10 +17138,10 @@ void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short HPMHooks.source.clif.buyingstore_update_item(sd, nameid, amount); } if( HPMHooks.count.HP_clif_buyingstore_update_item_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *amount); + void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, unsigned short amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_update_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyingstore_update_item_post[hIndex].func; - postHookFunc(sd, &nameid, &amount); + postHookFunc(sd, nameid, amount); } } return; @@ -17097,11 +17149,11 @@ void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, unsigned short amount, int price) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_delete_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *index, unsigned short *amount, int *price); + void (*preHookFunc) (struct map_session_data **sd, short *index, unsigned short *amount, int *price); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_delete_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_delete_item_pre[hIndex].func; - preHookFunc(sd, &index, &amount, &price); + preHookFunc(&sd, &index, &amount, &price); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17112,10 +17164,10 @@ void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, u HPMHooks.source.clif.buyingstore_delete_item(sd, index, amount, price); } if( HPMHooks.count.HP_clif_buyingstore_delete_item_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *index, unsigned short *amount, int *price); + void (*postHookFunc) (struct map_session_data *sd, short index, unsigned short amount, int price); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_delete_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyingstore_delete_item_post[hIndex].func; - postHookFunc(sd, &index, &amount, &price); + postHookFunc(sd, index, amount, price); } } return; @@ -17123,11 +17175,11 @@ void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, u void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short result, unsigned short nameid) { int hIndex = 0; if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *result, unsigned short *nameid); + void (*preHookFunc) (struct map_session_data **sd, short *result, unsigned short *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_seller_pre[hIndex].func; - preHookFunc(sd, &result, &nameid); + preHookFunc(&sd, &result, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17138,10 +17190,10 @@ void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short HPMHooks.source.clif.buyingstore_trade_failed_seller(sd, result, nameid); } if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *result, unsigned short *nameid); + void (*postHookFunc) (struct map_session_data *sd, short result, unsigned short nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_seller_post[hIndex].func; - postHookFunc(sd, &result, &nameid); + postHookFunc(sd, result, nameid); } } return; @@ -17149,11 +17201,11 @@ void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short void HP_clif_search_store_info_ack(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_search_store_info_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_search_store_info_ack_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17175,11 +17227,11 @@ void HP_clif_search_store_info_ack(struct map_session_data *sd) { void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char reason) { int hIndex = 0; if( HPMHooks.count.HP_clif_search_store_info_failed_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *reason); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *reason); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_failed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_search_store_info_failed_pre[hIndex].func; - preHookFunc(sd, &reason); + preHookFunc(&sd, &reason); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17190,10 +17242,10 @@ void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char HPMHooks.source.clif.search_store_info_failed(sd, reason); } if( HPMHooks.count.HP_clif_search_store_info_failed_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *reason); + void (*postHookFunc) (struct map_session_data *sd, unsigned char reason); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_failed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_search_store_info_failed_post[hIndex].func; - postHookFunc(sd, &reason); + postHookFunc(sd, reason); } } return; @@ -17201,11 +17253,11 @@ void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char void HP_clif_open_search_store_info(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_open_search_store_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_open_search_store_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_open_search_store_info_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17227,11 +17279,11 @@ void HP_clif_open_search_store_info(struct map_session_data *sd) { void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, short y) { int hIndex = 0; if( HPMHooks.count.HP_clif_search_store_info_click_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *x, short *y); + void (*preHookFunc) (struct map_session_data **sd, short *x, short *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_click_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_search_store_info_click_ack_pre[hIndex].func; - preHookFunc(sd, &x, &y); + preHookFunc(&sd, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17242,10 +17294,10 @@ void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, s HPMHooks.source.clif.search_store_info_click_ack(sd, x, y); } if( HPMHooks.count.HP_clif_search_store_info_click_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *x, short *y); + void (*postHookFunc) (struct map_session_data *sd, short x, short y); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_click_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_search_store_info_click_ack_post[hIndex].func; - postHookFunc(sd, &x, &y); + postHookFunc(sd, x, y); } } return; @@ -17253,11 +17305,11 @@ void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, s void HP_clif_elemental_info(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_elemental_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_elemental_info_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17279,11 +17331,11 @@ void HP_clif_elemental_info(struct map_session_data *sd) { void HP_clif_elemental_updatestatus(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_elemental_updatestatus_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_updatestatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_elemental_updatestatus_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17294,10 +17346,10 @@ void HP_clif_elemental_updatestatus(struct map_session_data *sd, int type) { HPMHooks.source.clif.elemental_updatestatus(sd, type); } if( HPMHooks.count.HP_clif_elemental_updatestatus_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_updatestatus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_elemental_updatestatus_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -17305,11 +17357,11 @@ void HP_clif_elemental_updatestatus(struct map_session_data *sd, int type) { void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id); + void (*preHookFunc) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_ack_pre[hIndex].func; - preHookFunc(sd, &response, &arena_id); + preHookFunc(&sd, &response, &arena_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17320,10 +17372,10 @@ void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_A HPMHooks.source.clif.bgqueue_ack(sd, response, arena_id); } if( HPMHooks.count.HP_clif_bgqueue_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id); + void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bgqueue_ack_post[hIndex].func; - postHookFunc(sd, &response, &arena_id); + postHookFunc(sd, response, arena_id); } } return; @@ -17331,11 +17383,11 @@ void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_A void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_notice_delete_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, const char *name); + void (*preHookFunc) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_notice_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_notice_delete_pre[hIndex].func; - preHookFunc(sd, &response, name); + preHookFunc(&sd, &response, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17346,10 +17398,10 @@ void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUN HPMHooks.source.clif.bgqueue_notice_delete(sd, response, name); } if( HPMHooks.count.HP_clif_bgqueue_notice_delete_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, const char *name); + void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_notice_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bgqueue_notice_delete_post[hIndex].func; - postHookFunc(sd, &response, name); + postHookFunc(sd, response, name); } } return; @@ -17357,11 +17409,11 @@ void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUN void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char arena_id, int position) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_update_info_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *arena_id, int *position); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *arena_id, int *position); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_update_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_update_info_pre[hIndex].func; - preHookFunc(sd, &arena_id, &position); + preHookFunc(&sd, &arena_id, &position); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17372,10 +17424,10 @@ void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char aren HPMHooks.source.clif.bgqueue_update_info(sd, arena_id, position); } if( HPMHooks.count.HP_clif_bgqueue_update_info_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *arena_id, int *position); + void (*postHookFunc) (struct map_session_data *sd, unsigned char arena_id, int position); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_update_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bgqueue_update_info_post[hIndex].func; - postHookFunc(sd, &arena_id, &position); + postHookFunc(sd, arena_id, position); } } return; @@ -17383,11 +17435,11 @@ void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char aren void HP_clif_bgqueue_joined(struct map_session_data *sd, int pos) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_joined_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *pos); + void (*preHookFunc) (struct map_session_data **sd, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_joined_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_joined_pre[hIndex].func; - preHookFunc(sd, &pos); + preHookFunc(&sd, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17398,10 +17450,10 @@ void HP_clif_bgqueue_joined(struct map_session_data *sd, int pos) { HPMHooks.source.clif.bgqueue_joined(sd, pos); } if( HPMHooks.count.HP_clif_bgqueue_joined_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *pos); + void (*postHookFunc) (struct map_session_data *sd, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_joined_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bgqueue_joined_post[hIndex].func; - postHookFunc(sd, &pos); + postHookFunc(sd, pos); } } return; @@ -17409,11 +17461,11 @@ void HP_clif_bgqueue_joined(struct map_session_data *sd, int pos) { void HP_clif_bgqueue_pcleft(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_pcleft_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_pcleft_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_pcleft_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17435,11 +17487,11 @@ void HP_clif_bgqueue_pcleft(struct map_session_data *sd) { void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char arena_id, enum send_target target) { int hIndex = 0; if( HPMHooks.count.HP_clif_bgqueue_battlebegins_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *arena_id, enum send_target *target); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *arena_id, enum send_target *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_battlebegins_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bgqueue_battlebegins_pre[hIndex].func; - preHookFunc(sd, &arena_id, &target); + preHookFunc(&sd, &arena_id, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17450,10 +17502,10 @@ void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char are HPMHooks.source.clif.bgqueue_battlebegins(sd, arena_id, target); } if( HPMHooks.count.HP_clif_bgqueue_battlebegins_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *arena_id, enum send_target *target); + void (*postHookFunc) (struct map_session_data *sd, unsigned char arena_id, enum send_target target); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_battlebegins_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bgqueue_battlebegins_post[hIndex].func; - postHookFunc(sd, &arena_id, &target); + postHookFunc(sd, arena_id, target); } } return; @@ -17461,11 +17513,11 @@ void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char are void HP_clif_adopt_reply(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_adopt_reply_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_reply_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_adopt_reply_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17476,10 +17528,10 @@ void HP_clif_adopt_reply(struct map_session_data *sd, int type) { HPMHooks.source.clif.adopt_reply(sd, type); } if( HPMHooks.count.HP_clif_adopt_reply_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_reply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_adopt_reply_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -17487,11 +17539,11 @@ void HP_clif_adopt_reply(struct map_session_data *sd, int type) { void HP_clif_adopt_request(struct map_session_data *sd, struct map_session_data *src, int p_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_adopt_request_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *src, int *p_id); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **src, int *p_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_request_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_adopt_request_pre[hIndex].func; - preHookFunc(sd, src, &p_id); + preHookFunc(&sd, &src, &p_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17502,10 +17554,10 @@ void HP_clif_adopt_request(struct map_session_data *sd, struct map_session_data HPMHooks.source.clif.adopt_request(sd, src, p_id); } if( HPMHooks.count.HP_clif_adopt_request_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *src, int *p_id); + void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *src, int p_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_adopt_request_post[hIndex].func; - postHookFunc(sd, src, &p_id); + postHookFunc(sd, src, p_id); } } return; @@ -17528,10 +17580,10 @@ void HP_clif_readbook(int fd, int book_id, int page) { HPMHooks.source.clif.readbook(fd, book_id, page); } if( HPMHooks.count.HP_clif_readbook_post ) { - void (*postHookFunc) (int *fd, int *book_id, int *page); + void (*postHookFunc) (int fd, int book_id, int page); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_readbook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_readbook_post[hIndex].func; - postHookFunc(&fd, &book_id, &page); + postHookFunc(fd, book_id, page); } } return; @@ -17539,11 +17591,11 @@ void HP_clif_readbook(int fd, int book_id, int page) { void HP_clif_notify_time(struct map_session_data *sd, int64 time) { int hIndex = 0; if( HPMHooks.count.HP_clif_notify_time_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int64 *time); + void (*preHookFunc) (struct map_session_data **sd, int64 *time); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_time_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_notify_time_pre[hIndex].func; - preHookFunc(sd, &time); + preHookFunc(&sd, &time); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17554,10 +17606,10 @@ void HP_clif_notify_time(struct map_session_data *sd, int64 time) { HPMHooks.source.clif.notify_time(sd, time); } if( HPMHooks.count.HP_clif_notify_time_post ) { - void (*postHookFunc) (struct map_session_data *sd, int64 *time); + void (*postHookFunc) (struct map_session_data *sd, int64 time); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_time_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_notify_time_post[hIndex].func; - postHookFunc(sd, &time); + postHookFunc(sd, time); } } return; @@ -17565,11 +17617,11 @@ void HP_clif_notify_time(struct map_session_data *sd, int64 time) { void HP_clif_user_count(struct map_session_data *sd, int count) { int hIndex = 0; if( HPMHooks.count.HP_clif_user_count_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *count); + void (*preHookFunc) (struct map_session_data **sd, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_user_count_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_user_count_pre[hIndex].func; - preHookFunc(sd, &count); + preHookFunc(&sd, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17580,10 +17632,10 @@ void HP_clif_user_count(struct map_session_data *sd, int count) { HPMHooks.source.clif.user_count(sd, count); } if( HPMHooks.count.HP_clif_user_count_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *count); + void (*postHookFunc) (struct map_session_data *sd, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_user_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_user_count_post[hIndex].func; - postHookFunc(sd, &count); + postHookFunc(sd, count); } } return; @@ -17591,11 +17643,11 @@ void HP_clif_user_count(struct map_session_data *sd, int count) { void HP_clif_noask_sub(struct map_session_data *src, struct map_session_data *target, int type) { int hIndex = 0; if( HPMHooks.count.HP_clif_noask_sub_pre ) { - void (*preHookFunc) (struct map_session_data *src, struct map_session_data *target, int *type); + void (*preHookFunc) (struct map_session_data **src, struct map_session_data **target, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_noask_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_noask_sub_pre[hIndex].func; - preHookFunc(src, target, &type); + preHookFunc(&src, &target, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17606,10 +17658,10 @@ void HP_clif_noask_sub(struct map_session_data *src, struct map_session_data *ta HPMHooks.source.clif.noask_sub(src, target, type); } if( HPMHooks.count.HP_clif_noask_sub_post ) { - void (*postHookFunc) (struct map_session_data *src, struct map_session_data *target, int *type); + void (*postHookFunc) (struct map_session_data *src, struct map_session_data *target, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_noask_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_noask_sub_post[hIndex].func; - postHookFunc(src, target, &type); + postHookFunc(src, target, type); } } return; @@ -17643,11 +17695,11 @@ void HP_clif_bc_ready(void) { void HP_clif_channel_msg(struct channel_data *chan, struct map_session_data *sd, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_clif_channel_msg_pre ) { - void (*preHookFunc) (struct channel_data *chan, struct map_session_data *sd, char *msg); + void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_channel_msg_pre[hIndex].func; - preHookFunc(chan, sd, msg); + preHookFunc(&chan, &sd, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17669,11 +17721,11 @@ void HP_clif_channel_msg(struct channel_data *chan, struct map_session_data *sd, void HP_clif_channel_msg2(struct channel_data *chan, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_clif_channel_msg2_pre ) { - void (*preHookFunc) (struct channel_data *chan, char *msg); + void (*preHookFunc) (struct channel_data **chan, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_channel_msg2_pre[hIndex].func; - preHookFunc(chan, msg); + preHookFunc(&chan, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17711,10 +17763,10 @@ int HP_clif_undisguise_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.clif.undisguise_timer(tid, tick, id, data); } if( HPMHooks.count.HP_clif_undisguise_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_undisguise_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_undisguise_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -17722,11 +17774,11 @@ int HP_clif_undisguise_timer(int tid, int64 tick, int id, intptr_t data) { void HP_clif_bank_deposit(struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK reason) { int hIndex = 0; if( HPMHooks.count.HP_clif_bank_deposit_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK *reason); + void (*preHookFunc) (struct map_session_data **sd, enum e_BANKING_DEPOSIT_ACK *reason); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_deposit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bank_deposit_pre[hIndex].func; - preHookFunc(sd, &reason); + preHookFunc(&sd, &reason); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17737,10 +17789,10 @@ void HP_clif_bank_deposit(struct map_session_data *sd, enum e_BANKING_DEPOSIT_AC HPMHooks.source.clif.bank_deposit(sd, reason); } if( HPMHooks.count.HP_clif_bank_deposit_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK *reason); + void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK reason); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_deposit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bank_deposit_post[hIndex].func; - postHookFunc(sd, &reason); + postHookFunc(sd, reason); } } return; @@ -17748,11 +17800,11 @@ void HP_clif_bank_deposit(struct map_session_data *sd, enum e_BANKING_DEPOSIT_AC void HP_clif_bank_withdraw(struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK reason) { int hIndex = 0; if( HPMHooks.count.HP_clif_bank_withdraw_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK *reason); + void (*preHookFunc) (struct map_session_data **sd, enum e_BANKING_WITHDRAW_ACK *reason); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_withdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_bank_withdraw_pre[hIndex].func; - preHookFunc(sd, &reason); + preHookFunc(&sd, &reason); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17763,10 +17815,10 @@ void HP_clif_bank_withdraw(struct map_session_data *sd, enum e_BANKING_WITHDRAW_ HPMHooks.source.clif.bank_withdraw(sd, reason); } if( HPMHooks.count.HP_clif_bank_withdraw_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK *reason); + void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK reason); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_bank_withdraw_post[hIndex].func; - postHookFunc(sd, &reason); + postHookFunc(sd, reason); } } return; @@ -17774,11 +17826,11 @@ void HP_clif_bank_withdraw(struct map_session_data *sd, enum e_BANKING_WITHDRAW_ void HP_clif_show_modifiers(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_show_modifiers_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_show_modifiers_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_show_modifiers_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17800,11 +17852,11 @@ void HP_clif_show_modifiers(struct map_session_data *sd) { void HP_clif_notify_bounditem(struct map_session_data *sd, unsigned short index) { int hIndex = 0; if( HPMHooks.count.HP_clif_notify_bounditem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned short *index); + void (*preHookFunc) (struct map_session_data **sd, unsigned short *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_bounditem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_notify_bounditem_pre[hIndex].func; - preHookFunc(sd, &index); + preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17815,10 +17867,10 @@ void HP_clif_notify_bounditem(struct map_session_data *sd, unsigned short index) HPMHooks.source.clif.notify_bounditem(sd, index); } if( HPMHooks.count.HP_clif_notify_bounditem_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned short *index); + void (*postHookFunc) (struct map_session_data *sd, unsigned short index); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_bounditem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_notify_bounditem_post[hIndex].func; - postHookFunc(sd, &index); + postHookFunc(sd, index); } } return; @@ -17827,11 +17879,11 @@ int HP_clif_delay_damage(int64 tick, struct block_list *src, struct block_list * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_delay_damage_pre ) { - int (*preHookFunc) (int64 *tick, struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *in_damage, short *div, unsigned char *type); + int (*preHookFunc) (int64 *tick, struct block_list **src, struct block_list **dst, int *sdelay, int *ddelay, int64 *in_damage, short *div, unsigned char *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_delay_damage_pre[hIndex].func; - retVal___ = preHookFunc(&tick, src, dst, &sdelay, &ddelay, &in_damage, &div, &type); + retVal___ = preHookFunc(&tick, &src, &dst, &sdelay, &ddelay, &in_damage, &div, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17842,10 +17894,10 @@ int HP_clif_delay_damage(int64 tick, struct block_list *src, struct block_list * retVal___ = HPMHooks.source.clif.delay_damage(tick, src, dst, sdelay, ddelay, in_damage, div, type); } if( HPMHooks.count.HP_clif_delay_damage_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *in_damage, short *div, unsigned char *type); + int (*postHookFunc) (int retVal___, int64 tick, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 in_damage, short div, unsigned char type); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_delay_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, src, dst, &sdelay, &ddelay, &in_damage, &div, &type); + retVal___ = postHookFunc(retVal___, tick, src, dst, sdelay, ddelay, in_damage, div, type); } } return retVal___; @@ -17869,10 +17921,10 @@ int HP_clif_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.clif.delay_damage_sub(tid, tick, id, data); } if( HPMHooks.count.HP_clif_delay_damage_sub_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_delay_damage_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -17880,11 +17932,11 @@ int HP_clif_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) { void HP_clif_npc_market_open(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_clif_npc_market_open_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_npc_market_open_pre[hIndex].func; - preHookFunc(sd, nd); + preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17906,11 +17958,11 @@ void HP_clif_npc_market_open(struct map_session_data *sd, struct npc_data *nd) { void HP_clif_npc_market_purchase_ack(struct map_session_data *sd, const struct itemlist *item_list, unsigned char response) { int hIndex = 0; if( HPMHooks.count.HP_clif_npc_market_purchase_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const struct itemlist *item_list, unsigned char *response); + void (*preHookFunc) (struct map_session_data **sd, const struct itemlist **item_list, unsigned char *response); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_purchase_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_npc_market_purchase_ack_pre[hIndex].func; - preHookFunc(sd, item_list, &response); + preHookFunc(&sd, &item_list, &response); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17921,10 +17973,10 @@ void HP_clif_npc_market_purchase_ack(struct map_session_data *sd, const struct i HPMHooks.source.clif.npc_market_purchase_ack(sd, item_list, response); } if( HPMHooks.count.HP_clif_npc_market_purchase_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, const struct itemlist *item_list, unsigned char *response); + void (*postHookFunc) (struct map_session_data *sd, const struct itemlist *item_list, unsigned char response); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_purchase_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_npc_market_purchase_ack_post[hIndex].func; - postHookFunc(sd, item_list, &response); + postHookFunc(sd, item_list, response); } } return; @@ -17959,11 +18011,11 @@ bool HP_clif_parse_roulette_db(void) { void HP_clif_roulette_generate_ack(struct map_session_data *sd, unsigned char result, short stage, short prizeIdx, short bonusItemID) { int hIndex = 0; if( HPMHooks.count.HP_clif_roulette_generate_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *result, short *stage, short *prizeIdx, short *bonusItemID); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *result, short *stage, short *prizeIdx, short *bonusItemID); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_roulette_generate_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_roulette_generate_ack_pre[hIndex].func; - preHookFunc(sd, &result, &stage, &prizeIdx, &bonusItemID); + preHookFunc(&sd, &result, &stage, &prizeIdx, &bonusItemID); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -17974,10 +18026,10 @@ void HP_clif_roulette_generate_ack(struct map_session_data *sd, unsigned char re HPMHooks.source.clif.roulette_generate_ack(sd, result, stage, prizeIdx, bonusItemID); } if( HPMHooks.count.HP_clif_roulette_generate_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *result, short *stage, short *prizeIdx, short *bonusItemID); + void (*postHookFunc) (struct map_session_data *sd, unsigned char result, short stage, short prizeIdx, short bonusItemID); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_roulette_generate_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_roulette_generate_ack_post[hIndex].func; - postHookFunc(sd, &result, &stage, &prizeIdx, &bonusItemID); + postHookFunc(sd, result, stage, prizeIdx, bonusItemID); } } return; @@ -17985,11 +18037,11 @@ void HP_clif_roulette_generate_ack(struct map_session_data *sd, unsigned char re void HP_clif_openmergeitem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_openmergeitem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openmergeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_openmergeitem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18000,10 +18052,10 @@ void HP_clif_openmergeitem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.openmergeitem(fd, sd); } if( HPMHooks.count.HP_clif_openmergeitem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openmergeitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_openmergeitem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18011,11 +18063,11 @@ void HP_clif_openmergeitem(int fd, struct map_session_data *sd) { void HP_clif_cancelmergeitem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_cancelmergeitem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cancelmergeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_cancelmergeitem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18026,10 +18078,10 @@ void HP_clif_cancelmergeitem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.cancelmergeitem(fd, sd); } if( HPMHooks.count.HP_clif_cancelmergeitem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cancelmergeitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_cancelmergeitem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18038,11 +18090,11 @@ int HP_clif_comparemergeitem(const void *a, const void *b) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_clif_comparemergeitem_pre ) { - int (*preHookFunc) (const void *a, const void *b); + int (*preHookFunc) (const void **a, const void **b); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_comparemergeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_comparemergeitem_pre[hIndex].func; - retVal___ = preHookFunc(a, b); + retVal___ = preHookFunc(&a, &b); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18064,11 +18116,11 @@ int HP_clif_comparemergeitem(const void *a, const void *b) { void HP_clif_ackmergeitems(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_ackmergeitems_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ackmergeitems_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_ackmergeitems_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18079,22 +18131,76 @@ void HP_clif_ackmergeitems(int fd, struct map_session_data *sd) { HPMHooks.source.clif.ackmergeitems(fd, sd); } if( HPMHooks.count.HP_clif_ackmergeitems_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ackmergeitems_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_ackmergeitems_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; } +bool HP_clif_isdisguised(struct block_list *bl) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_clif_isdisguised_pre ) { + bool (*preHookFunc) (struct block_list **bl); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_isdisguised_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_clif_isdisguised_pre[hIndex].func; + retVal___ = preHookFunc(&bl); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.clif.isdisguised(bl); + } + if( HPMHooks.count.HP_clif_isdisguised_post ) { + bool (*postHookFunc) (bool retVal___, struct block_list *bl); + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_isdisguised_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_clif_isdisguised_post[hIndex].func; + retVal___ = postHookFunc(retVal___, bl); + } + } + return retVal___; +} +unsigned char HP_clif_bl_type(struct block_list *bl) { + int hIndex = 0; + unsigned char retVal___ = 0; + if( HPMHooks.count.HP_clif_bl_type_pre ) { + unsigned char (*preHookFunc) (struct block_list **bl); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bl_type_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_clif_bl_type_pre[hIndex].func; + retVal___ = preHookFunc(&bl); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.clif.bl_type(bl); + } + if( HPMHooks.count.HP_clif_bl_type_post ) { + unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl); + for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bl_type_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_clif_bl_type_post[hIndex].func; + retVal___ = postHookFunc(retVal___, bl); + } + } + return retVal___; +} void HP_clif_pWantToConnection(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pWantToConnection_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pWantToConnection_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18105,10 +18211,10 @@ void HP_clif_pWantToConnection(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pWantToConnection(fd, sd); } if( HPMHooks.count.HP_clif_pWantToConnection_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pWantToConnection_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18116,11 +18222,11 @@ void HP_clif_pWantToConnection(int fd, struct map_session_data *sd) { void HP_clif_pLoadEndAck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pLoadEndAck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18131,10 +18237,10 @@ void HP_clif_pLoadEndAck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pLoadEndAck(fd, sd); } if( HPMHooks.count.HP_clif_pLoadEndAck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18142,11 +18248,11 @@ void HP_clif_pLoadEndAck(int fd, struct map_session_data *sd) { void HP_clif_pTickSend(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTickSend_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTickSend_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18157,10 +18263,10 @@ void HP_clif_pTickSend(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTickSend(fd, sd); } if( HPMHooks.count.HP_clif_pTickSend_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTickSend_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18168,11 +18274,11 @@ void HP_clif_pTickSend(int fd, struct map_session_data *sd) { void HP_clif_pHotkey(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHotkey_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHotkey_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18183,10 +18289,10 @@ void HP_clif_pHotkey(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHotkey(fd, sd); } if( HPMHooks.count.HP_clif_pHotkey_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHotkey_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18194,11 +18300,11 @@ void HP_clif_pHotkey(int fd, struct map_session_data *sd) { void HP_clif_pProgressbar(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pProgressbar_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pProgressbar_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18209,10 +18315,10 @@ void HP_clif_pProgressbar(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pProgressbar(fd, sd); } if( HPMHooks.count.HP_clif_pProgressbar_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pProgressbar_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18220,11 +18326,11 @@ void HP_clif_pProgressbar(int fd, struct map_session_data *sd) { void HP_clif_pWalkToXY(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pWalkToXY_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pWalkToXY_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18235,10 +18341,10 @@ void HP_clif_pWalkToXY(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pWalkToXY(fd, sd); } if( HPMHooks.count.HP_clif_pWalkToXY_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pWalkToXY_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18246,11 +18352,11 @@ void HP_clif_pWalkToXY(int fd, struct map_session_data *sd) { void HP_clif_pQuitGame(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pQuitGame_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pQuitGame_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18261,10 +18367,10 @@ void HP_clif_pQuitGame(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pQuitGame(fd, sd); } if( HPMHooks.count.HP_clif_pQuitGame_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pQuitGame_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18272,11 +18378,11 @@ void HP_clif_pQuitGame(int fd, struct map_session_data *sd) { void HP_clif_pGetCharNameRequest(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGetCharNameRequest_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18287,10 +18393,10 @@ void HP_clif_pGetCharNameRequest(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGetCharNameRequest(fd, sd); } if( HPMHooks.count.HP_clif_pGetCharNameRequest_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18298,11 +18404,11 @@ void HP_clif_pGetCharNameRequest(int fd, struct map_session_data *sd) { void HP_clif_pGlobalMessage(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGlobalMessage_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18313,10 +18419,10 @@ void HP_clif_pGlobalMessage(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGlobalMessage(fd, sd); } if( HPMHooks.count.HP_clif_pGlobalMessage_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18324,11 +18430,11 @@ void HP_clif_pGlobalMessage(int fd, struct map_session_data *sd) { void HP_clif_pMapMove(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMapMove_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMapMove_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18339,10 +18445,10 @@ void HP_clif_pMapMove(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMapMove(fd, sd); } if( HPMHooks.count.HP_clif_pMapMove_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMapMove_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18350,11 +18456,11 @@ void HP_clif_pMapMove(int fd, struct map_session_data *sd) { void HP_clif_pChangeDir(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChangeDir_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChangeDir_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18365,10 +18471,10 @@ void HP_clif_pChangeDir(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChangeDir(fd, sd); } if( HPMHooks.count.HP_clif_pChangeDir_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChangeDir_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18376,11 +18482,11 @@ void HP_clif_pChangeDir(int fd, struct map_session_data *sd) { void HP_clif_pEmotion(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pEmotion_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pEmotion_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18391,10 +18497,10 @@ void HP_clif_pEmotion(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pEmotion(fd, sd); } if( HPMHooks.count.HP_clif_pEmotion_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pEmotion_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18402,11 +18508,11 @@ void HP_clif_pEmotion(int fd, struct map_session_data *sd) { void HP_clif_pHowManyConnections(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHowManyConnections_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18417,10 +18523,10 @@ void HP_clif_pHowManyConnections(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHowManyConnections(fd, sd); } if( HPMHooks.count.HP_clif_pHowManyConnections_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18428,11 +18534,11 @@ void HP_clif_pHowManyConnections(int fd, struct map_session_data *sd) { void HP_clif_pActionRequest(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pActionRequest_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pActionRequest_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18443,10 +18549,10 @@ void HP_clif_pActionRequest(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pActionRequest(fd, sd); } if( HPMHooks.count.HP_clif_pActionRequest_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pActionRequest_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18454,11 +18560,11 @@ void HP_clif_pActionRequest(int fd, struct map_session_data *sd) { void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, int target_id, int64 tick) { int hIndex = 0; if( HPMHooks.count.HP_clif_pActionRequest_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *action_type, int *target_id, int64 *tick); + void (*preHookFunc) (struct map_session_data **sd, int *action_type, int *target_id, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pActionRequest_sub_pre[hIndex].func; - preHookFunc(sd, &action_type, &target_id, &tick); + preHookFunc(&sd, &action_type, &target_id, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18469,10 +18575,10 @@ void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, in HPMHooks.source.clif.pActionRequest_sub(sd, action_type, target_id, tick); } if( HPMHooks.count.HP_clif_pActionRequest_sub_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *action_type, int *target_id, int64 *tick); + void (*postHookFunc) (struct map_session_data *sd, int action_type, int target_id, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pActionRequest_sub_post[hIndex].func; - postHookFunc(sd, &action_type, &target_id, &tick); + postHookFunc(sd, action_type, target_id, tick); } } return; @@ -18480,11 +18586,11 @@ void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, in void HP_clif_pRestart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRestart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRestart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18495,10 +18601,10 @@ void HP_clif_pRestart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRestart(fd, sd); } if( HPMHooks.count.HP_clif_pRestart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRestart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18506,11 +18612,11 @@ void HP_clif_pRestart(int fd, struct map_session_data *sd) { void HP_clif_pWisMessage(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pWisMessage_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pWisMessage_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18521,10 +18627,10 @@ void HP_clif_pWisMessage(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pWisMessage(fd, sd); } if( HPMHooks.count.HP_clif_pWisMessage_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pWisMessage_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18532,11 +18638,11 @@ void HP_clif_pWisMessage(int fd, struct map_session_data *sd) { void HP_clif_pBroadcast(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBroadcast_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBroadcast_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18547,10 +18653,10 @@ void HP_clif_pBroadcast(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBroadcast(fd, sd); } if( HPMHooks.count.HP_clif_pBroadcast_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBroadcast_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18558,11 +18664,11 @@ void HP_clif_pBroadcast(int fd, struct map_session_data *sd) { void HP_clif_pTakeItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTakeItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTakeItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18573,10 +18679,10 @@ void HP_clif_pTakeItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTakeItem(fd, sd); } if( HPMHooks.count.HP_clif_pTakeItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTakeItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18584,11 +18690,11 @@ void HP_clif_pTakeItem(int fd, struct map_session_data *sd) { void HP_clif_pDropItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pDropItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pDropItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18599,10 +18705,10 @@ void HP_clif_pDropItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pDropItem(fd, sd); } if( HPMHooks.count.HP_clif_pDropItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pDropItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18610,11 +18716,11 @@ void HP_clif_pDropItem(int fd, struct map_session_data *sd) { void HP_clif_pUseItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18625,10 +18731,10 @@ void HP_clif_pUseItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseItem(fd, sd); } if( HPMHooks.count.HP_clif_pUseItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18636,11 +18742,11 @@ void HP_clif_pUseItem(int fd, struct map_session_data *sd) { void HP_clif_pEquipItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pEquipItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pEquipItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18651,10 +18757,10 @@ void HP_clif_pEquipItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pEquipItem(fd, sd); } if( HPMHooks.count.HP_clif_pEquipItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pEquipItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18662,11 +18768,11 @@ void HP_clif_pEquipItem(int fd, struct map_session_data *sd) { void HP_clif_pUnequipItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUnequipItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUnequipItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18677,10 +18783,10 @@ void HP_clif_pUnequipItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUnequipItem(fd, sd); } if( HPMHooks.count.HP_clif_pUnequipItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUnequipItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18688,11 +18794,11 @@ void HP_clif_pUnequipItem(int fd, struct map_session_data *sd) { void HP_clif_pNpcClicked(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcClicked_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcClicked_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18703,10 +18809,10 @@ void HP_clif_pNpcClicked(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcClicked(fd, sd); } if( HPMHooks.count.HP_clif_pNpcClicked_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcClicked_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18714,11 +18820,11 @@ void HP_clif_pNpcClicked(int fd, struct map_session_data *sd) { void HP_clif_pNpcBuySellSelected(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcBuySellSelected_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18729,10 +18835,10 @@ void HP_clif_pNpcBuySellSelected(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcBuySellSelected(fd, sd); } if( HPMHooks.count.HP_clif_pNpcBuySellSelected_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18740,11 +18846,11 @@ void HP_clif_pNpcBuySellSelected(int fd, struct map_session_data *sd) { void HP_clif_pNpcBuyListSend(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcBuyListSend_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18755,10 +18861,10 @@ void HP_clif_pNpcBuyListSend(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcBuyListSend(fd, sd); } if( HPMHooks.count.HP_clif_pNpcBuyListSend_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18766,11 +18872,11 @@ void HP_clif_pNpcBuyListSend(int fd, struct map_session_data *sd) { void HP_clif_pNpcSellListSend(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcSellListSend_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18781,10 +18887,10 @@ void HP_clif_pNpcSellListSend(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcSellListSend(fd, sd); } if( HPMHooks.count.HP_clif_pNpcSellListSend_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18792,11 +18898,11 @@ void HP_clif_pNpcSellListSend(int fd, struct map_session_data *sd) { void HP_clif_pCreateChatRoom(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCreateChatRoom_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18807,10 +18913,10 @@ void HP_clif_pCreateChatRoom(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCreateChatRoom(fd, sd); } if( HPMHooks.count.HP_clif_pCreateChatRoom_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18818,11 +18924,11 @@ void HP_clif_pCreateChatRoom(int fd, struct map_session_data *sd) { void HP_clif_pChatAddMember(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChatAddMember_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChatAddMember_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18833,10 +18939,10 @@ void HP_clif_pChatAddMember(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChatAddMember(fd, sd); } if( HPMHooks.count.HP_clif_pChatAddMember_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChatAddMember_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18844,11 +18950,11 @@ void HP_clif_pChatAddMember(int fd, struct map_session_data *sd) { void HP_clif_pChatRoomStatusChange(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChatRoomStatusChange_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18859,10 +18965,10 @@ void HP_clif_pChatRoomStatusChange(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChatRoomStatusChange(fd, sd); } if( HPMHooks.count.HP_clif_pChatRoomStatusChange_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18870,11 +18976,11 @@ void HP_clif_pChatRoomStatusChange(int fd, struct map_session_data *sd) { void HP_clif_pChangeChatOwner(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChangeChatOwner_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18885,10 +18991,10 @@ void HP_clif_pChangeChatOwner(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChangeChatOwner(fd, sd); } if( HPMHooks.count.HP_clif_pChangeChatOwner_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18896,11 +19002,11 @@ void HP_clif_pChangeChatOwner(int fd, struct map_session_data *sd) { void HP_clif_pKickFromChat(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pKickFromChat_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pKickFromChat_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18911,10 +19017,10 @@ void HP_clif_pKickFromChat(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pKickFromChat(fd, sd); } if( HPMHooks.count.HP_clif_pKickFromChat_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pKickFromChat_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18922,11 +19028,11 @@ void HP_clif_pKickFromChat(int fd, struct map_session_data *sd) { void HP_clif_pChatLeave(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChatLeave_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChatLeave_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18937,10 +19043,10 @@ void HP_clif_pChatLeave(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChatLeave(fd, sd); } if( HPMHooks.count.HP_clif_pChatLeave_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChatLeave_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18948,11 +19054,11 @@ void HP_clif_pChatLeave(int fd, struct map_session_data *sd) { void HP_clif_pTradeRequest(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeRequest_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeRequest_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18963,10 +19069,10 @@ void HP_clif_pTradeRequest(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeRequest(fd, sd); } if( HPMHooks.count.HP_clif_pTradeRequest_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeRequest_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -18974,11 +19080,11 @@ void HP_clif_pTradeRequest(int fd, struct map_session_data *sd) { void HP_clif_pTradeAck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeAck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeAck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -18989,10 +19095,10 @@ void HP_clif_pTradeAck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeAck(fd, sd); } if( HPMHooks.count.HP_clif_pTradeAck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeAck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19000,11 +19106,11 @@ void HP_clif_pTradeAck(int fd, struct map_session_data *sd) { void HP_clif_pTradeAddItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeAddItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19015,10 +19121,10 @@ void HP_clif_pTradeAddItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeAddItem(fd, sd); } if( HPMHooks.count.HP_clif_pTradeAddItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19026,11 +19132,11 @@ void HP_clif_pTradeAddItem(int fd, struct map_session_data *sd) { void HP_clif_pTradeOk(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeOk_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeOk_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19041,10 +19147,10 @@ void HP_clif_pTradeOk(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeOk(fd, sd); } if( HPMHooks.count.HP_clif_pTradeOk_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeOk_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19052,11 +19158,11 @@ void HP_clif_pTradeOk(int fd, struct map_session_data *sd) { void HP_clif_pTradeCancel(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeCancel_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeCancel_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19067,10 +19173,10 @@ void HP_clif_pTradeCancel(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeCancel(fd, sd); } if( HPMHooks.count.HP_clif_pTradeCancel_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeCancel_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19078,11 +19184,11 @@ void HP_clif_pTradeCancel(int fd, struct map_session_data *sd) { void HP_clif_pTradeCommit(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTradeCommit_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTradeCommit_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19093,10 +19199,10 @@ void HP_clif_pTradeCommit(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTradeCommit(fd, sd); } if( HPMHooks.count.HP_clif_pTradeCommit_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTradeCommit_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19104,11 +19210,11 @@ void HP_clif_pTradeCommit(int fd, struct map_session_data *sd) { void HP_clif_pStopAttack(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pStopAttack_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pStopAttack_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19119,10 +19225,10 @@ void HP_clif_pStopAttack(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pStopAttack(fd, sd); } if( HPMHooks.count.HP_clif_pStopAttack_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pStopAttack_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19130,11 +19236,11 @@ void HP_clif_pStopAttack(int fd, struct map_session_data *sd) { void HP_clif_pPutItemToCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPutItemToCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19145,10 +19251,10 @@ void HP_clif_pPutItemToCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPutItemToCart(fd, sd); } if( HPMHooks.count.HP_clif_pPutItemToCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19156,11 +19262,11 @@ void HP_clif_pPutItemToCart(int fd, struct map_session_data *sd) { void HP_clif_pGetItemFromCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGetItemFromCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19171,10 +19277,10 @@ void HP_clif_pGetItemFromCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGetItemFromCart(fd, sd); } if( HPMHooks.count.HP_clif_pGetItemFromCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19182,11 +19288,11 @@ void HP_clif_pGetItemFromCart(int fd, struct map_session_data *sd) { void HP_clif_pRemoveOption(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRemoveOption_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRemoveOption_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19197,10 +19303,10 @@ void HP_clif_pRemoveOption(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRemoveOption(fd, sd); } if( HPMHooks.count.HP_clif_pRemoveOption_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRemoveOption_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19208,11 +19314,11 @@ void HP_clif_pRemoveOption(int fd, struct map_session_data *sd) { void HP_clif_pChangeCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChangeCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChangeCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19223,10 +19329,10 @@ void HP_clif_pChangeCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChangeCart(fd, sd); } if( HPMHooks.count.HP_clif_pChangeCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChangeCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19234,11 +19340,11 @@ void HP_clif_pChangeCart(int fd, struct map_session_data *sd) { void HP_clif_pStatusUp(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pStatusUp_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pStatusUp_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19249,10 +19355,10 @@ void HP_clif_pStatusUp(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pStatusUp(fd, sd); } if( HPMHooks.count.HP_clif_pStatusUp_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pStatusUp_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19260,11 +19366,11 @@ void HP_clif_pStatusUp(int fd, struct map_session_data *sd) { void HP_clif_pSkillUp(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSkillUp_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSkillUp_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19275,10 +19381,10 @@ void HP_clif_pSkillUp(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSkillUp(fd, sd); } if( HPMHooks.count.HP_clif_pSkillUp_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSkillUp_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19286,11 +19392,11 @@ void HP_clif_pSkillUp(int fd, struct map_session_data *sd) { void HP_clif_pUseSkillToId(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToId_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19301,10 +19407,10 @@ void HP_clif_pUseSkillToId(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseSkillToId(fd, sd); } if( HPMHooks.count.HP_clif_pUseSkillToId_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19312,11 +19418,11 @@ void HP_clif_pUseSkillToId(int fd, struct map_session_data *sd) { void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToId_homun_pre ) { - void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); + void (*preHookFunc) (struct homun_data **hd, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_homun_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_homun_pre[hIndex].func; - preHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &target_id); + preHookFunc(&hd, &sd, &tick, &skill_id, &skill_lv, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19327,10 +19433,10 @@ void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data HPMHooks.source.clif.pUseSkillToId_homun(hd, sd, tick, skill_id, skill_lv, target_id); } if( HPMHooks.count.HP_clif_pUseSkillToId_homun_post ) { - void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); + void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_homun_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_homun_post[hIndex].func; - postHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &target_id); + postHookFunc(hd, sd, tick, skill_id, skill_lv, target_id); } } return; @@ -19338,11 +19444,11 @@ void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre ) { - void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); + void (*preHookFunc) (struct mercenary_data **md, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_mercenary_pre[hIndex].func; - preHookFunc(md, sd, &tick, &skill_id, &skill_lv, &target_id); + preHookFunc(&md, &sd, &tick, &skill_id, &skill_lv, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19353,10 +19459,10 @@ void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_sessi HPMHooks.source.clif.pUseSkillToId_mercenary(md, sd, tick, skill_id, skill_lv, target_id); } if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post ) { - void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id); + void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_mercenary_post[hIndex].func; - postHookFunc(md, sd, &tick, &skill_id, &skill_lv, &target_id); + postHookFunc(md, sd, tick, skill_id, skill_lv, target_id); } } return; @@ -19364,11 +19470,11 @@ void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_sessi void HP_clif_pUseSkillToPos(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToPos_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19379,10 +19485,10 @@ void HP_clif_pUseSkillToPos(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseSkillToPos(fd, sd); } if( HPMHooks.count.HP_clif_pUseSkillToPos_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19390,11 +19496,11 @@ void HP_clif_pUseSkillToPos(int fd, struct map_session_data *sd) { void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToPosSub_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo); + void (*preHookFunc) (int *fd, struct map_session_data **sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosSub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosSub_pre[hIndex].func; - preHookFunc(&fd, sd, &skill_lv, &skill_id, &x, &y, &skillmoreinfo); + preHookFunc(&fd, &sd, &skill_lv, &skill_id, &x, &y, &skillmoreinfo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19405,10 +19511,10 @@ void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill HPMHooks.source.clif.pUseSkillToPosSub(fd, sd, skill_lv, skill_id, x, y, skillmoreinfo); } if( HPMHooks.count.HP_clif_pUseSkillToPosSub_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo); + void (*postHookFunc) (int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosSub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosSub_post[hIndex].func; - postHookFunc(&fd, sd, &skill_lv, &skill_id, &x, &y, &skillmoreinfo); + postHookFunc(fd, sd, skill_lv, skill_id, x, y, skillmoreinfo); } } return; @@ -19416,11 +19522,11 @@ void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre ) { - void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); + void (*preHookFunc) (struct homun_data **hd, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_homun_pre[hIndex].func; - preHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); + preHookFunc(&hd, &sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19431,10 +19537,10 @@ void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data HPMHooks.source.clif.pUseSkillToPos_homun(hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo); } if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_post ) { - void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); + void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_homun_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_homun_post[hIndex].func; - postHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); + postHookFunc(hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo); } } return; @@ -19442,11 +19548,11 @@ void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre ) { - void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); + void (*preHookFunc) (struct mercenary_data **md, struct map_session_data **sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_mercenary_pre[hIndex].func; - preHookFunc(md, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); + preHookFunc(&md, &sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19457,10 +19563,10 @@ void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_sess HPMHooks.source.clif.pUseSkillToPos_mercenary(md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo); } if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post ) { - void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo); + void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_mercenary_post[hIndex].func; - postHookFunc(md, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo); + postHookFunc(md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo); } } return; @@ -19468,11 +19574,11 @@ void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_sess void HP_clif_pUseSkillToPosMoreInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19483,10 +19589,10 @@ void HP_clif_pUseSkillToPosMoreInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseSkillToPosMoreInfo(fd, sd); } if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19494,11 +19600,11 @@ void HP_clif_pUseSkillToPosMoreInfo(int fd, struct map_session_data *sd) { void HP_clif_pUseSkillMap(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseSkillMap_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19509,10 +19615,10 @@ void HP_clif_pUseSkillMap(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseSkillMap(fd, sd); } if( HPMHooks.count.HP_clif_pUseSkillMap_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19520,11 +19626,11 @@ void HP_clif_pUseSkillMap(int fd, struct map_session_data *sd) { void HP_clif_pRequestMemo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRequestMemo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRequestMemo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19535,10 +19641,10 @@ void HP_clif_pRequestMemo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRequestMemo(fd, sd); } if( HPMHooks.count.HP_clif_pRequestMemo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRequestMemo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19546,11 +19652,11 @@ void HP_clif_pRequestMemo(int fd, struct map_session_data *sd) { void HP_clif_pProduceMix(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pProduceMix_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pProduceMix_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19561,10 +19667,10 @@ void HP_clif_pProduceMix(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pProduceMix(fd, sd); } if( HPMHooks.count.HP_clif_pProduceMix_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pProduceMix_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19572,11 +19678,11 @@ void HP_clif_pProduceMix(int fd, struct map_session_data *sd) { void HP_clif_pCooking(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCooking_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCooking_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19587,10 +19693,10 @@ void HP_clif_pCooking(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCooking(fd, sd); } if( HPMHooks.count.HP_clif_pCooking_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCooking_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19598,11 +19704,11 @@ void HP_clif_pCooking(int fd, struct map_session_data *sd) { void HP_clif_pRepairItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRepairItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRepairItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19613,10 +19719,10 @@ void HP_clif_pRepairItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRepairItem(fd, sd); } if( HPMHooks.count.HP_clif_pRepairItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRepairItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19624,11 +19730,11 @@ void HP_clif_pRepairItem(int fd, struct map_session_data *sd) { void HP_clif_pWeaponRefine(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pWeaponRefine_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19639,10 +19745,10 @@ void HP_clif_pWeaponRefine(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pWeaponRefine(fd, sd); } if( HPMHooks.count.HP_clif_pWeaponRefine_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19650,11 +19756,11 @@ void HP_clif_pWeaponRefine(int fd, struct map_session_data *sd) { void HP_clif_pNpcSelectMenu(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcSelectMenu_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19665,10 +19771,10 @@ void HP_clif_pNpcSelectMenu(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcSelectMenu(fd, sd); } if( HPMHooks.count.HP_clif_pNpcSelectMenu_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19676,11 +19782,11 @@ void HP_clif_pNpcSelectMenu(int fd, struct map_session_data *sd) { void HP_clif_pNpcNextClicked(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcNextClicked_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19691,10 +19797,10 @@ void HP_clif_pNpcNextClicked(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcNextClicked(fd, sd); } if( HPMHooks.count.HP_clif_pNpcNextClicked_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19702,11 +19808,11 @@ void HP_clif_pNpcNextClicked(int fd, struct map_session_data *sd) { void HP_clif_pNpcAmountInput(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcAmountInput_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19717,10 +19823,10 @@ void HP_clif_pNpcAmountInput(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcAmountInput(fd, sd); } if( HPMHooks.count.HP_clif_pNpcAmountInput_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19728,11 +19834,11 @@ void HP_clif_pNpcAmountInput(int fd, struct map_session_data *sd) { void HP_clif_pNpcStringInput(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcStringInput_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19743,10 +19849,10 @@ void HP_clif_pNpcStringInput(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcStringInput(fd, sd); } if( HPMHooks.count.HP_clif_pNpcStringInput_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19754,11 +19860,11 @@ void HP_clif_pNpcStringInput(int fd, struct map_session_data *sd) { void HP_clif_pNpcCloseClicked(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNpcCloseClicked_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19769,10 +19875,10 @@ void HP_clif_pNpcCloseClicked(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNpcCloseClicked(fd, sd); } if( HPMHooks.count.HP_clif_pNpcCloseClicked_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19780,11 +19886,11 @@ void HP_clif_pNpcCloseClicked(int fd, struct map_session_data *sd) { void HP_clif_pItemIdentify(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pItemIdentify_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pItemIdentify_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19795,10 +19901,10 @@ void HP_clif_pItemIdentify(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pItemIdentify(fd, sd); } if( HPMHooks.count.HP_clif_pItemIdentify_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pItemIdentify_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19806,11 +19912,11 @@ void HP_clif_pItemIdentify(int fd, struct map_session_data *sd) { void HP_clif_pSelectArrow(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSelectArrow_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSelectArrow_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19821,10 +19927,10 @@ void HP_clif_pSelectArrow(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSelectArrow(fd, sd); } if( HPMHooks.count.HP_clif_pSelectArrow_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSelectArrow_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19832,11 +19938,11 @@ void HP_clif_pSelectArrow(int fd, struct map_session_data *sd) { void HP_clif_pAutoSpell(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAutoSpell_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAutoSpell_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19847,10 +19953,10 @@ void HP_clif_pAutoSpell(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAutoSpell(fd, sd); } if( HPMHooks.count.HP_clif_pAutoSpell_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAutoSpell_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19858,11 +19964,11 @@ void HP_clif_pAutoSpell(int fd, struct map_session_data *sd) { void HP_clif_pUseCard(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pUseCard_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pUseCard_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19873,10 +19979,10 @@ void HP_clif_pUseCard(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pUseCard(fd, sd); } if( HPMHooks.count.HP_clif_pUseCard_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pUseCard_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19884,11 +19990,11 @@ void HP_clif_pUseCard(int fd, struct map_session_data *sd) { void HP_clif_pInsertCard(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pInsertCard_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pInsertCard_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19899,10 +20005,10 @@ void HP_clif_pInsertCard(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pInsertCard(fd, sd); } if( HPMHooks.count.HP_clif_pInsertCard_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pInsertCard_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19910,11 +20016,11 @@ void HP_clif_pInsertCard(int fd, struct map_session_data *sd) { void HP_clif_pSolveCharName(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSolveCharName_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSolveCharName_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19925,10 +20031,10 @@ void HP_clif_pSolveCharName(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSolveCharName(fd, sd); } if( HPMHooks.count.HP_clif_pSolveCharName_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSolveCharName_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19936,11 +20042,11 @@ void HP_clif_pSolveCharName(int fd, struct map_session_data *sd) { void HP_clif_pResetChar(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pResetChar_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pResetChar_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19951,10 +20057,10 @@ void HP_clif_pResetChar(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pResetChar(fd, sd); } if( HPMHooks.count.HP_clif_pResetChar_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pResetChar_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19962,11 +20068,11 @@ void HP_clif_pResetChar(int fd, struct map_session_data *sd) { void HP_clif_pLocalBroadcast(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pLocalBroadcast_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -19977,10 +20083,10 @@ void HP_clif_pLocalBroadcast(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pLocalBroadcast(fd, sd); } if( HPMHooks.count.HP_clif_pLocalBroadcast_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -19988,11 +20094,11 @@ void HP_clif_pLocalBroadcast(int fd, struct map_session_data *sd) { void HP_clif_pMoveToKafra(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMoveToKafra_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20003,10 +20109,10 @@ void HP_clif_pMoveToKafra(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMoveToKafra(fd, sd); } if( HPMHooks.count.HP_clif_pMoveToKafra_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20014,11 +20120,11 @@ void HP_clif_pMoveToKafra(int fd, struct map_session_data *sd) { void HP_clif_pMoveFromKafra(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMoveFromKafra_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20029,10 +20135,10 @@ void HP_clif_pMoveFromKafra(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMoveFromKafra(fd, sd); } if( HPMHooks.count.HP_clif_pMoveFromKafra_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20040,11 +20146,11 @@ void HP_clif_pMoveFromKafra(int fd, struct map_session_data *sd) { void HP_clif_pMoveToKafraFromCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20055,10 +20161,10 @@ void HP_clif_pMoveToKafraFromCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMoveToKafraFromCart(fd, sd); } if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20066,11 +20172,11 @@ void HP_clif_pMoveToKafraFromCart(int fd, struct map_session_data *sd) { void HP_clif_pMoveFromKafraToCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20081,10 +20187,10 @@ void HP_clif_pMoveFromKafraToCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMoveFromKafraToCart(fd, sd); } if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20092,11 +20198,11 @@ void HP_clif_pMoveFromKafraToCart(int fd, struct map_session_data *sd) { void HP_clif_pCloseKafra(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCloseKafra_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCloseKafra_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20107,10 +20213,10 @@ void HP_clif_pCloseKafra(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCloseKafra(fd, sd); } if( HPMHooks.count.HP_clif_pCloseKafra_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCloseKafra_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20118,11 +20224,11 @@ void HP_clif_pCloseKafra(int fd, struct map_session_data *sd) { void HP_clif_pStoragePassword(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pStoragePassword_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pStoragePassword_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20133,10 +20239,10 @@ void HP_clif_pStoragePassword(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pStoragePassword(fd, sd); } if( HPMHooks.count.HP_clif_pStoragePassword_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pStoragePassword_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20144,11 +20250,11 @@ void HP_clif_pStoragePassword(int fd, struct map_session_data *sd) { void HP_clif_pCreateParty(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCreateParty_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCreateParty_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20159,10 +20265,10 @@ void HP_clif_pCreateParty(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCreateParty(fd, sd); } if( HPMHooks.count.HP_clif_pCreateParty_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCreateParty_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20170,11 +20276,11 @@ void HP_clif_pCreateParty(int fd, struct map_session_data *sd) { void HP_clif_pCreateParty2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCreateParty2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCreateParty2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20185,10 +20291,10 @@ void HP_clif_pCreateParty2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCreateParty2(fd, sd); } if( HPMHooks.count.HP_clif_pCreateParty2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCreateParty2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20196,11 +20302,11 @@ void HP_clif_pCreateParty2(int fd, struct map_session_data *sd) { void HP_clif_pPartyInvite(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyInvite_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyInvite_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20211,10 +20317,10 @@ void HP_clif_pPartyInvite(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyInvite(fd, sd); } if( HPMHooks.count.HP_clif_pPartyInvite_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyInvite_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20222,11 +20328,11 @@ void HP_clif_pPartyInvite(int fd, struct map_session_data *sd) { void HP_clif_pPartyInvite2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyInvite2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20237,10 +20343,10 @@ void HP_clif_pPartyInvite2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyInvite2(fd, sd); } if( HPMHooks.count.HP_clif_pPartyInvite2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20248,11 +20354,11 @@ void HP_clif_pPartyInvite2(int fd, struct map_session_data *sd) { void HP_clif_pReplyPartyInvite(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReplyPartyInvite_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20263,10 +20369,10 @@ void HP_clif_pReplyPartyInvite(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReplyPartyInvite(fd, sd); } if( HPMHooks.count.HP_clif_pReplyPartyInvite_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20274,11 +20380,11 @@ void HP_clif_pReplyPartyInvite(int fd, struct map_session_data *sd) { void HP_clif_pReplyPartyInvite2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReplyPartyInvite2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20289,10 +20395,10 @@ void HP_clif_pReplyPartyInvite2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReplyPartyInvite2(fd, sd); } if( HPMHooks.count.HP_clif_pReplyPartyInvite2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20300,11 +20406,11 @@ void HP_clif_pReplyPartyInvite2(int fd, struct map_session_data *sd) { void HP_clif_pLeaveParty(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pLeaveParty_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pLeaveParty_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20315,10 +20421,10 @@ void HP_clif_pLeaveParty(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pLeaveParty(fd, sd); } if( HPMHooks.count.HP_clif_pLeaveParty_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pLeaveParty_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20326,11 +20432,11 @@ void HP_clif_pLeaveParty(int fd, struct map_session_data *sd) { void HP_clif_pRemovePartyMember(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRemovePartyMember_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20341,10 +20447,10 @@ void HP_clif_pRemovePartyMember(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRemovePartyMember(fd, sd); } if( HPMHooks.count.HP_clif_pRemovePartyMember_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20352,11 +20458,11 @@ void HP_clif_pRemovePartyMember(int fd, struct map_session_data *sd) { void HP_clif_pPartyChangeOption(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyChangeOption_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20367,10 +20473,10 @@ void HP_clif_pPartyChangeOption(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyChangeOption(fd, sd); } if( HPMHooks.count.HP_clif_pPartyChangeOption_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20378,11 +20484,11 @@ void HP_clif_pPartyChangeOption(int fd, struct map_session_data *sd) { void HP_clif_pPartyMessage(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyMessage_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyMessage_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20393,10 +20499,10 @@ void HP_clif_pPartyMessage(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyMessage(fd, sd); } if( HPMHooks.count.HP_clif_pPartyMessage_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyMessage_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20404,11 +20510,11 @@ void HP_clif_pPartyMessage(int fd, struct map_session_data *sd) { void HP_clif_pPartyChangeLeader(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyChangeLeader_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20419,10 +20525,10 @@ void HP_clif_pPartyChangeLeader(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyChangeLeader(fd, sd); } if( HPMHooks.count.HP_clif_pPartyChangeLeader_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20430,11 +20536,11 @@ void HP_clif_pPartyChangeLeader(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingRegisterReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20445,10 +20551,10 @@ void HP_clif_pPartyBookingRegisterReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingRegisterReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20456,11 +20562,11 @@ void HP_clif_pPartyBookingRegisterReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingSearchReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20471,10 +20577,10 @@ void HP_clif_pPartyBookingSearchReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingSearchReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20482,11 +20588,11 @@ void HP_clif_pPartyBookingSearchReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingDeleteReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20497,10 +20603,10 @@ void HP_clif_pPartyBookingDeleteReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingDeleteReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20508,11 +20614,11 @@ void HP_clif_pPartyBookingDeleteReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingUpdateReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20523,10 +20629,10 @@ void HP_clif_pPartyBookingUpdateReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingUpdateReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20534,11 +20640,11 @@ void HP_clif_pPartyBookingUpdateReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyRecruitRegisterReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitRegisterReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20549,10 +20655,10 @@ void HP_clif_pPartyRecruitRegisterReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyRecruitRegisterReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitRegisterReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20560,11 +20666,11 @@ void HP_clif_pPartyRecruitRegisterReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyRecruitSearchReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyRecruitSearchReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitSearchReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitSearchReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20575,10 +20681,10 @@ void HP_clif_pPartyRecruitSearchReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyRecruitSearchReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyRecruitSearchReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitSearchReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitSearchReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20586,11 +20692,11 @@ void HP_clif_pPartyRecruitSearchReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyRecruitDeleteReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitDeleteReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20601,10 +20707,10 @@ void HP_clif_pPartyRecruitDeleteReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyRecruitDeleteReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitDeleteReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20612,11 +20718,11 @@ void HP_clif_pPartyRecruitDeleteReq(int fd, struct map_session_data *sd) { void HP_clif_pPartyRecruitUpdateReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitUpdateReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20627,10 +20733,10 @@ void HP_clif_pPartyRecruitUpdateReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyRecruitUpdateReq(fd, sd); } if( HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitUpdateReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20638,11 +20744,11 @@ void HP_clif_pPartyRecruitUpdateReq(int fd, struct map_session_data *sd) { void HP_clif_pCloseVending(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCloseVending_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCloseVending_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20653,10 +20759,10 @@ void HP_clif_pCloseVending(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCloseVending(fd, sd); } if( HPMHooks.count.HP_clif_pCloseVending_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCloseVending_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20664,11 +20770,11 @@ void HP_clif_pCloseVending(int fd, struct map_session_data *sd) { void HP_clif_pVendingListReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pVendingListReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pVendingListReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20679,10 +20785,10 @@ void HP_clif_pVendingListReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pVendingListReq(fd, sd); } if( HPMHooks.count.HP_clif_pVendingListReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pVendingListReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20690,11 +20796,11 @@ void HP_clif_pVendingListReq(int fd, struct map_session_data *sd) { void HP_clif_pPurchaseReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPurchaseReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20705,10 +20811,10 @@ void HP_clif_pPurchaseReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPurchaseReq(fd, sd); } if( HPMHooks.count.HP_clif_pPurchaseReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20716,11 +20822,11 @@ void HP_clif_pPurchaseReq(int fd, struct map_session_data *sd) { void HP_clif_pPurchaseReq2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPurchaseReq2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20731,10 +20837,10 @@ void HP_clif_pPurchaseReq2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPurchaseReq2(fd, sd); } if( HPMHooks.count.HP_clif_pPurchaseReq2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20742,11 +20848,11 @@ void HP_clif_pPurchaseReq2(int fd, struct map_session_data *sd) { void HP_clif_pOpenVending(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pOpenVending_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pOpenVending_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20757,10 +20863,10 @@ void HP_clif_pOpenVending(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pOpenVending(fd, sd); } if( HPMHooks.count.HP_clif_pOpenVending_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pOpenVending_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20768,11 +20874,11 @@ void HP_clif_pOpenVending(int fd, struct map_session_data *sd) { void HP_clif_pCreateGuild(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCreateGuild_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCreateGuild_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20783,10 +20889,10 @@ void HP_clif_pCreateGuild(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCreateGuild(fd, sd); } if( HPMHooks.count.HP_clif_pCreateGuild_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCreateGuild_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20794,11 +20900,11 @@ void HP_clif_pCreateGuild(int fd, struct map_session_data *sd) { void HP_clif_pGuildCheckMaster(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildCheckMaster_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20809,10 +20915,10 @@ void HP_clif_pGuildCheckMaster(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildCheckMaster(fd, sd); } if( HPMHooks.count.HP_clif_pGuildCheckMaster_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20820,11 +20926,11 @@ void HP_clif_pGuildCheckMaster(int fd, struct map_session_data *sd) { void HP_clif_pGuildRequestInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildRequestInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20835,10 +20941,10 @@ void HP_clif_pGuildRequestInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildRequestInfo(fd, sd); } if( HPMHooks.count.HP_clif_pGuildRequestInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20846,11 +20952,11 @@ void HP_clif_pGuildRequestInfo(int fd, struct map_session_data *sd) { void HP_clif_pGuildChangePositionInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20861,10 +20967,10 @@ void HP_clif_pGuildChangePositionInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildChangePositionInfo(fd, sd); } if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20872,11 +20978,11 @@ void HP_clif_pGuildChangePositionInfo(int fd, struct map_session_data *sd) { void HP_clif_pGuildChangeMemberPosition(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20887,10 +20993,10 @@ void HP_clif_pGuildChangeMemberPosition(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildChangeMemberPosition(fd, sd); } if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20898,11 +21004,11 @@ void HP_clif_pGuildChangeMemberPosition(int fd, struct map_session_data *sd) { void HP_clif_pGuildRequestEmblem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildRequestEmblem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20913,10 +21019,10 @@ void HP_clif_pGuildRequestEmblem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildRequestEmblem(fd, sd); } if( HPMHooks.count.HP_clif_pGuildRequestEmblem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20924,11 +21030,11 @@ void HP_clif_pGuildRequestEmblem(int fd, struct map_session_data *sd) { void HP_clif_pGuildChangeEmblem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildChangeEmblem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20939,10 +21045,10 @@ void HP_clif_pGuildChangeEmblem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildChangeEmblem(fd, sd); } if( HPMHooks.count.HP_clif_pGuildChangeEmblem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20950,11 +21056,11 @@ void HP_clif_pGuildChangeEmblem(int fd, struct map_session_data *sd) { void HP_clif_pGuildChangeNotice(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildChangeNotice_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20965,10 +21071,10 @@ void HP_clif_pGuildChangeNotice(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildChangeNotice(fd, sd); } if( HPMHooks.count.HP_clif_pGuildChangeNotice_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -20976,11 +21082,11 @@ void HP_clif_pGuildChangeNotice(int fd, struct map_session_data *sd) { void HP_clif_pGuildInvite(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildInvite_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildInvite_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -20991,10 +21097,10 @@ void HP_clif_pGuildInvite(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildInvite(fd, sd); } if( HPMHooks.count.HP_clif_pGuildInvite_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildInvite_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21002,11 +21108,11 @@ void HP_clif_pGuildInvite(int fd, struct map_session_data *sd) { void HP_clif_pGuildReplyInvite(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildReplyInvite_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21017,10 +21123,10 @@ void HP_clif_pGuildReplyInvite(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildReplyInvite(fd, sd); } if( HPMHooks.count.HP_clif_pGuildReplyInvite_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21028,11 +21134,11 @@ void HP_clif_pGuildReplyInvite(int fd, struct map_session_data *sd) { void HP_clif_pGuildLeave(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildLeave_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildLeave_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21043,10 +21149,10 @@ void HP_clif_pGuildLeave(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildLeave(fd, sd); } if( HPMHooks.count.HP_clif_pGuildLeave_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildLeave_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21054,11 +21160,11 @@ void HP_clif_pGuildLeave(int fd, struct map_session_data *sd) { void HP_clif_pGuildExpulsion(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildExpulsion_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21069,10 +21175,10 @@ void HP_clif_pGuildExpulsion(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildExpulsion(fd, sd); } if( HPMHooks.count.HP_clif_pGuildExpulsion_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21080,11 +21186,11 @@ void HP_clif_pGuildExpulsion(int fd, struct map_session_data *sd) { void HP_clif_pGuildMessage(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildMessage_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildMessage_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21095,10 +21201,10 @@ void HP_clif_pGuildMessage(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildMessage(fd, sd); } if( HPMHooks.count.HP_clif_pGuildMessage_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildMessage_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21106,11 +21212,11 @@ void HP_clif_pGuildMessage(int fd, struct map_session_data *sd) { void HP_clif_pGuildRequestAlliance(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildRequestAlliance_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21121,10 +21227,10 @@ void HP_clif_pGuildRequestAlliance(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildRequestAlliance(fd, sd); } if( HPMHooks.count.HP_clif_pGuildRequestAlliance_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21132,11 +21238,11 @@ void HP_clif_pGuildRequestAlliance(int fd, struct map_session_data *sd) { void HP_clif_pGuildReplyAlliance(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildReplyAlliance_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21147,10 +21253,10 @@ void HP_clif_pGuildReplyAlliance(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildReplyAlliance(fd, sd); } if( HPMHooks.count.HP_clif_pGuildReplyAlliance_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21158,11 +21264,11 @@ void HP_clif_pGuildReplyAlliance(int fd, struct map_session_data *sd) { void HP_clif_pGuildDelAlliance(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildDelAlliance_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21173,10 +21279,10 @@ void HP_clif_pGuildDelAlliance(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildDelAlliance(fd, sd); } if( HPMHooks.count.HP_clif_pGuildDelAlliance_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21184,11 +21290,11 @@ void HP_clif_pGuildDelAlliance(int fd, struct map_session_data *sd) { void HP_clif_pGuildOpposition(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildOpposition_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21199,10 +21305,10 @@ void HP_clif_pGuildOpposition(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildOpposition(fd, sd); } if( HPMHooks.count.HP_clif_pGuildOpposition_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21210,11 +21316,11 @@ void HP_clif_pGuildOpposition(int fd, struct map_session_data *sd) { void HP_clif_pGuildBreak(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildBreak_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildBreak_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21225,10 +21331,10 @@ void HP_clif_pGuildBreak(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildBreak(fd, sd); } if( HPMHooks.count.HP_clif_pGuildBreak_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildBreak_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21236,11 +21342,11 @@ void HP_clif_pGuildBreak(int fd, struct map_session_data *sd) { void HP_clif_pPetMenu(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPetMenu_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPetMenu_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21251,10 +21357,10 @@ void HP_clif_pPetMenu(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPetMenu(fd, sd); } if( HPMHooks.count.HP_clif_pPetMenu_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPetMenu_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21262,11 +21368,11 @@ void HP_clif_pPetMenu(int fd, struct map_session_data *sd) { void HP_clif_pCatchPet(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCatchPet_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCatchPet_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21277,10 +21383,10 @@ void HP_clif_pCatchPet(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCatchPet(fd, sd); } if( HPMHooks.count.HP_clif_pCatchPet_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCatchPet_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21288,11 +21394,11 @@ void HP_clif_pCatchPet(int fd, struct map_session_data *sd) { void HP_clif_pSelectEgg(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSelectEgg_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSelectEgg_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21303,10 +21409,10 @@ void HP_clif_pSelectEgg(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSelectEgg(fd, sd); } if( HPMHooks.count.HP_clif_pSelectEgg_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSelectEgg_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21314,11 +21420,11 @@ void HP_clif_pSelectEgg(int fd, struct map_session_data *sd) { void HP_clif_pSendEmotion(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSendEmotion_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSendEmotion_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21329,10 +21435,10 @@ void HP_clif_pSendEmotion(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSendEmotion(fd, sd); } if( HPMHooks.count.HP_clif_pSendEmotion_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSendEmotion_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21340,11 +21446,11 @@ void HP_clif_pSendEmotion(int fd, struct map_session_data *sd) { void HP_clif_pChangePetName(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChangePetName_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChangePetName_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21355,10 +21461,10 @@ void HP_clif_pChangePetName(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChangePetName(fd, sd); } if( HPMHooks.count.HP_clif_pChangePetName_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChangePetName_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21366,11 +21472,11 @@ void HP_clif_pChangePetName(int fd, struct map_session_data *sd) { void HP_clif_pGMKick(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMKick_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMKick_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21381,10 +21487,10 @@ void HP_clif_pGMKick(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMKick(fd, sd); } if( HPMHooks.count.HP_clif_pGMKick_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMKick_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21392,11 +21498,11 @@ void HP_clif_pGMKick(int fd, struct map_session_data *sd) { void HP_clif_pGMKickAll(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMKickAll_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMKickAll_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21407,10 +21513,10 @@ void HP_clif_pGMKickAll(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMKickAll(fd, sd); } if( HPMHooks.count.HP_clif_pGMKickAll_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMKickAll_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21418,11 +21524,11 @@ void HP_clif_pGMKickAll(int fd, struct map_session_data *sd) { void HP_clif_pGMShift(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMShift_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMShift_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21433,10 +21539,10 @@ void HP_clif_pGMShift(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMShift(fd, sd); } if( HPMHooks.count.HP_clif_pGMShift_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMShift_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21444,11 +21550,11 @@ void HP_clif_pGMShift(int fd, struct map_session_data *sd) { void HP_clif_pGMRemove2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMRemove2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMRemove2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21459,10 +21565,10 @@ void HP_clif_pGMRemove2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMRemove2(fd, sd); } if( HPMHooks.count.HP_clif_pGMRemove2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMRemove2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21470,11 +21576,11 @@ void HP_clif_pGMRemove2(int fd, struct map_session_data *sd) { void HP_clif_pGMRecall(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMRecall_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMRecall_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21485,10 +21591,10 @@ void HP_clif_pGMRecall(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMRecall(fd, sd); } if( HPMHooks.count.HP_clif_pGMRecall_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMRecall_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21496,11 +21602,11 @@ void HP_clif_pGMRecall(int fd, struct map_session_data *sd) { void HP_clif_pGMRecall2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMRecall2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMRecall2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21511,10 +21617,10 @@ void HP_clif_pGMRecall2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMRecall2(fd, sd); } if( HPMHooks.count.HP_clif_pGMRecall2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMRecall2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21522,11 +21628,11 @@ void HP_clif_pGMRecall2(int fd, struct map_session_data *sd) { void HP_clif_pGM_Monster_Item(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGM_Monster_Item_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGM_Monster_Item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGM_Monster_Item_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21537,10 +21643,10 @@ void HP_clif_pGM_Monster_Item(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGM_Monster_Item(fd, sd); } if( HPMHooks.count.HP_clif_pGM_Monster_Item_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGM_Monster_Item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGM_Monster_Item_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21548,11 +21654,11 @@ void HP_clif_pGM_Monster_Item(int fd, struct map_session_data *sd) { void HP_clif_pGMHide(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMHide_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMHide_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21563,10 +21669,10 @@ void HP_clif_pGMHide(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMHide(fd, sd); } if( HPMHooks.count.HP_clif_pGMHide_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMHide_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21574,11 +21680,11 @@ void HP_clif_pGMHide(int fd, struct map_session_data *sd) { void HP_clif_pGMReqNoChat(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMReqNoChat_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21589,10 +21695,10 @@ void HP_clif_pGMReqNoChat(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMReqNoChat(fd, sd); } if( HPMHooks.count.HP_clif_pGMReqNoChat_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21600,11 +21706,11 @@ void HP_clif_pGMReqNoChat(int fd, struct map_session_data *sd) { void HP_clif_pGMRc(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMRc_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMRc_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21615,10 +21721,10 @@ void HP_clif_pGMRc(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMRc(fd, sd); } if( HPMHooks.count.HP_clif_pGMRc_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMRc_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21626,11 +21732,11 @@ void HP_clif_pGMRc(int fd, struct map_session_data *sd) { void HP_clif_pGMReqAccountName(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMReqAccountName_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21641,10 +21747,10 @@ void HP_clif_pGMReqAccountName(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMReqAccountName(fd, sd); } if( HPMHooks.count.HP_clif_pGMReqAccountName_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21652,11 +21758,11 @@ void HP_clif_pGMReqAccountName(int fd, struct map_session_data *sd) { void HP_clif_pGMChangeMapType(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMChangeMapType_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21667,10 +21773,10 @@ void HP_clif_pGMChangeMapType(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMChangeMapType(fd, sd); } if( HPMHooks.count.HP_clif_pGMChangeMapType_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21678,11 +21784,11 @@ void HP_clif_pGMChangeMapType(int fd, struct map_session_data *sd) { void HP_clif_pGMFullStrip(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGMFullStrip_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMFullStrip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGMFullStrip_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21693,10 +21799,10 @@ void HP_clif_pGMFullStrip(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGMFullStrip(fd, sd); } if( HPMHooks.count.HP_clif_pGMFullStrip_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMFullStrip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGMFullStrip_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21704,11 +21810,11 @@ void HP_clif_pGMFullStrip(int fd, struct map_session_data *sd) { void HP_clif_pPMIgnore(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPMIgnore_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPMIgnore_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21719,10 +21825,10 @@ void HP_clif_pPMIgnore(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPMIgnore(fd, sd); } if( HPMHooks.count.HP_clif_pPMIgnore_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPMIgnore_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21730,11 +21836,11 @@ void HP_clif_pPMIgnore(int fd, struct map_session_data *sd) { void HP_clif_pPMIgnoreAll(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPMIgnoreAll_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21745,10 +21851,10 @@ void HP_clif_pPMIgnoreAll(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPMIgnoreAll(fd, sd); } if( HPMHooks.count.HP_clif_pPMIgnoreAll_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21756,11 +21862,11 @@ void HP_clif_pPMIgnoreAll(int fd, struct map_session_data *sd) { void HP_clif_pPMIgnoreList(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPMIgnoreList_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21771,10 +21877,10 @@ void HP_clif_pPMIgnoreList(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPMIgnoreList(fd, sd); } if( HPMHooks.count.HP_clif_pPMIgnoreList_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21782,11 +21888,11 @@ void HP_clif_pPMIgnoreList(int fd, struct map_session_data *sd) { void HP_clif_pNoviceDoriDori(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNoviceDoriDori_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21797,10 +21903,10 @@ void HP_clif_pNoviceDoriDori(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNoviceDoriDori(fd, sd); } if( HPMHooks.count.HP_clif_pNoviceDoriDori_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21808,11 +21914,11 @@ void HP_clif_pNoviceDoriDori(int fd, struct map_session_data *sd) { void HP_clif_pNoviceExplosionSpirits(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21823,10 +21929,10 @@ void HP_clif_pNoviceExplosionSpirits(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNoviceExplosionSpirits(fd, sd); } if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21834,11 +21940,11 @@ void HP_clif_pNoviceExplosionSpirits(int fd, struct map_session_data *sd) { void HP_clif_pFriendsListAdd(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pFriendsListAdd_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21849,10 +21955,10 @@ void HP_clif_pFriendsListAdd(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pFriendsListAdd(fd, sd); } if( HPMHooks.count.HP_clif_pFriendsListAdd_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21860,11 +21966,11 @@ void HP_clif_pFriendsListAdd(int fd, struct map_session_data *sd) { void HP_clif_pFriendsListReply(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pFriendsListReply_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21875,10 +21981,10 @@ void HP_clif_pFriendsListReply(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pFriendsListReply(fd, sd); } if( HPMHooks.count.HP_clif_pFriendsListReply_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21886,11 +21992,11 @@ void HP_clif_pFriendsListReply(int fd, struct map_session_data *sd) { void HP_clif_pFriendsListRemove(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pFriendsListRemove_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21901,10 +22007,10 @@ void HP_clif_pFriendsListRemove(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pFriendsListRemove(fd, sd); } if( HPMHooks.count.HP_clif_pFriendsListRemove_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21912,11 +22018,11 @@ void HP_clif_pFriendsListRemove(int fd, struct map_session_data *sd) { void HP_clif_pPVPInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPVPInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPVPInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21927,10 +22033,10 @@ void HP_clif_pPVPInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPVPInfo(fd, sd); } if( HPMHooks.count.HP_clif_pPVPInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPVPInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21938,11 +22044,11 @@ void HP_clif_pPVPInfo(int fd, struct map_session_data *sd) { void HP_clif_pBlacksmith(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBlacksmith_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBlacksmith_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21953,10 +22059,10 @@ void HP_clif_pBlacksmith(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBlacksmith(fd, sd); } if( HPMHooks.count.HP_clif_pBlacksmith_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBlacksmith_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21964,11 +22070,11 @@ void HP_clif_pBlacksmith(int fd, struct map_session_data *sd) { void HP_clif_pAlchemist(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAlchemist_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAlchemist_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -21979,10 +22085,10 @@ void HP_clif_pAlchemist(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAlchemist(fd, sd); } if( HPMHooks.count.HP_clif_pAlchemist_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAlchemist_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -21990,11 +22096,11 @@ void HP_clif_pAlchemist(int fd, struct map_session_data *sd) { void HP_clif_pTaekwon(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pTaekwon_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pTaekwon_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22005,10 +22111,10 @@ void HP_clif_pTaekwon(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pTaekwon(fd, sd); } if( HPMHooks.count.HP_clif_pTaekwon_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pTaekwon_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22016,11 +22122,11 @@ void HP_clif_pTaekwon(int fd, struct map_session_data *sd) { void HP_clif_pRankingPk(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRankingPk_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRankingPk_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22031,10 +22137,10 @@ void HP_clif_pRankingPk(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRankingPk(fd, sd); } if( HPMHooks.count.HP_clif_pRankingPk_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRankingPk_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22042,11 +22148,11 @@ void HP_clif_pRankingPk(int fd, struct map_session_data *sd) { void HP_clif_pFeelSaveOk(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pFeelSaveOk_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22057,10 +22163,10 @@ void HP_clif_pFeelSaveOk(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pFeelSaveOk(fd, sd); } if( HPMHooks.count.HP_clif_pFeelSaveOk_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22068,11 +22174,11 @@ void HP_clif_pFeelSaveOk(int fd, struct map_session_data *sd) { void HP_clif_pChangeHomunculusName(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pChangeHomunculusName_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22083,10 +22189,10 @@ void HP_clif_pChangeHomunculusName(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pChangeHomunculusName(fd, sd); } if( HPMHooks.count.HP_clif_pChangeHomunculusName_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22094,11 +22200,11 @@ void HP_clif_pChangeHomunculusName(int fd, struct map_session_data *sd) { void HP_clif_pHomMoveToMaster(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHomMoveToMaster_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22109,10 +22215,10 @@ void HP_clif_pHomMoveToMaster(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHomMoveToMaster(fd, sd); } if( HPMHooks.count.HP_clif_pHomMoveToMaster_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22120,11 +22226,11 @@ void HP_clif_pHomMoveToMaster(int fd, struct map_session_data *sd) { void HP_clif_pHomMoveTo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHomMoveTo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22135,10 +22241,10 @@ void HP_clif_pHomMoveTo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHomMoveTo(fd, sd); } if( HPMHooks.count.HP_clif_pHomMoveTo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22146,11 +22252,11 @@ void HP_clif_pHomMoveTo(int fd, struct map_session_data *sd) { void HP_clif_pHomAttack(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHomAttack_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHomAttack_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22161,10 +22267,10 @@ void HP_clif_pHomAttack(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHomAttack(fd, sd); } if( HPMHooks.count.HP_clif_pHomAttack_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHomAttack_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22172,11 +22278,11 @@ void HP_clif_pHomAttack(int fd, struct map_session_data *sd) { void HP_clif_pHomMenu(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHomMenu_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHomMenu_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22187,10 +22293,10 @@ void HP_clif_pHomMenu(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHomMenu(fd, sd); } if( HPMHooks.count.HP_clif_pHomMenu_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHomMenu_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22198,11 +22304,11 @@ void HP_clif_pHomMenu(int fd, struct map_session_data *sd) { void HP_clif_pAutoRevive(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAutoRevive_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAutoRevive_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22213,10 +22319,10 @@ void HP_clif_pAutoRevive(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAutoRevive(fd, sd); } if( HPMHooks.count.HP_clif_pAutoRevive_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAutoRevive_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22224,11 +22330,11 @@ void HP_clif_pAutoRevive(int fd, struct map_session_data *sd) { void HP_clif_pCheck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCheck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCheck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22239,10 +22345,10 @@ void HP_clif_pCheck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCheck(fd, sd); } if( HPMHooks.count.HP_clif_pCheck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCheck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22250,11 +22356,11 @@ void HP_clif_pCheck(int fd, struct map_session_data *sd) { void HP_clif_pMail_refreshinbox(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_refreshinbox_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_refreshinbox_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_refreshinbox_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22265,10 +22371,10 @@ void HP_clif_pMail_refreshinbox(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_refreshinbox(fd, sd); } if( HPMHooks.count.HP_clif_pMail_refreshinbox_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_refreshinbox_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_refreshinbox_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22276,11 +22382,11 @@ void HP_clif_pMail_refreshinbox(int fd, struct map_session_data *sd) { void HP_clif_pMail_read(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_read_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_read_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22291,10 +22397,10 @@ void HP_clif_pMail_read(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_read(fd, sd); } if( HPMHooks.count.HP_clif_pMail_read_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_read_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22302,11 +22408,11 @@ void HP_clif_pMail_read(int fd, struct map_session_data *sd) { void HP_clif_pMail_getattach(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_getattach_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_getattach_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_getattach_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22317,10 +22423,10 @@ void HP_clif_pMail_getattach(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_getattach(fd, sd); } if( HPMHooks.count.HP_clif_pMail_getattach_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_getattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_getattach_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22328,11 +22434,11 @@ void HP_clif_pMail_getattach(int fd, struct map_session_data *sd) { void HP_clif_pMail_delete(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_delete_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_delete_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22343,10 +22449,10 @@ void HP_clif_pMail_delete(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_delete(fd, sd); } if( HPMHooks.count.HP_clif_pMail_delete_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_delete_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22354,11 +22460,11 @@ void HP_clif_pMail_delete(int fd, struct map_session_data *sd) { void HP_clif_pMail_return(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_return_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_return_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_return_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22369,10 +22475,10 @@ void HP_clif_pMail_return(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_return(fd, sd); } if( HPMHooks.count.HP_clif_pMail_return_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_return_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_return_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22380,11 +22486,11 @@ void HP_clif_pMail_return(int fd, struct map_session_data *sd) { void HP_clif_pMail_setattach(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_setattach_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_setattach_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_setattach_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22395,10 +22501,10 @@ void HP_clif_pMail_setattach(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_setattach(fd, sd); } if( HPMHooks.count.HP_clif_pMail_setattach_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_setattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_setattach_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22406,11 +22512,11 @@ void HP_clif_pMail_setattach(int fd, struct map_session_data *sd) { void HP_clif_pMail_winopen(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_winopen_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_winopen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_winopen_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22421,10 +22527,10 @@ void HP_clif_pMail_winopen(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_winopen(fd, sd); } if( HPMHooks.count.HP_clif_pMail_winopen_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_winopen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_winopen_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22432,11 +22538,11 @@ void HP_clif_pMail_winopen(int fd, struct map_session_data *sd) { void HP_clif_pMail_send(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMail_send_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMail_send_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22447,10 +22553,10 @@ void HP_clif_pMail_send(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMail_send(fd, sd); } if( HPMHooks.count.HP_clif_pMail_send_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMail_send_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22458,11 +22564,11 @@ void HP_clif_pMail_send(int fd, struct map_session_data *sd) { void HP_clif_pAuction_cancelreg(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_cancelreg_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancelreg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_cancelreg_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22473,10 +22579,10 @@ void HP_clif_pAuction_cancelreg(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_cancelreg(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_cancelreg_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancelreg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_cancelreg_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22484,11 +22590,11 @@ void HP_clif_pAuction_cancelreg(int fd, struct map_session_data *sd) { void HP_clif_pAuction_setitem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_setitem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_setitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_setitem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22499,10 +22605,10 @@ void HP_clif_pAuction_setitem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_setitem(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_setitem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_setitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_setitem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22510,11 +22616,11 @@ void HP_clif_pAuction_setitem(int fd, struct map_session_data *sd) { void HP_clif_pAuction_register(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_register_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_register_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_register_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22525,10 +22631,10 @@ void HP_clif_pAuction_register(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_register(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_register_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_register_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_register_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22536,11 +22642,11 @@ void HP_clif_pAuction_register(int fd, struct map_session_data *sd) { void HP_clif_pAuction_cancel(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_cancel_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_cancel_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22551,10 +22657,10 @@ void HP_clif_pAuction_cancel(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_cancel(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_cancel_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_cancel_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22562,11 +22668,11 @@ void HP_clif_pAuction_cancel(int fd, struct map_session_data *sd) { void HP_clif_pAuction_close(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_close_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_close_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22577,10 +22683,10 @@ void HP_clif_pAuction_close(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_close(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_close_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_close_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22588,11 +22694,11 @@ void HP_clif_pAuction_close(int fd, struct map_session_data *sd) { void HP_clif_pAuction_bid(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_bid_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_bid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_bid_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22603,10 +22709,10 @@ void HP_clif_pAuction_bid(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_bid(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_bid_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_bid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_bid_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22614,11 +22720,11 @@ void HP_clif_pAuction_bid(int fd, struct map_session_data *sd) { void HP_clif_pAuction_search(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_search_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_search_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22629,10 +22735,10 @@ void HP_clif_pAuction_search(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_search(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_search_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_search_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22640,11 +22746,11 @@ void HP_clif_pAuction_search(int fd, struct map_session_data *sd) { void HP_clif_pAuction_buysell(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAuction_buysell_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_buysell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAuction_buysell_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22655,10 +22761,10 @@ void HP_clif_pAuction_buysell(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAuction_buysell(fd, sd); } if( HPMHooks.count.HP_clif_pAuction_buysell_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_buysell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAuction_buysell_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22666,11 +22772,11 @@ void HP_clif_pAuction_buysell(int fd, struct map_session_data *sd) { void HP_clif_pcashshop_buy(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pcashshop_buy_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pcashshop_buy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pcashshop_buy_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22681,10 +22787,10 @@ void HP_clif_pcashshop_buy(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pcashshop_buy(fd, sd); } if( HPMHooks.count.HP_clif_pcashshop_buy_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pcashshop_buy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pcashshop_buy_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22692,11 +22798,11 @@ void HP_clif_pcashshop_buy(int fd, struct map_session_data *sd) { void HP_clif_pAdopt_request(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAdopt_request_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_request_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAdopt_request_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22707,10 +22813,10 @@ void HP_clif_pAdopt_request(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAdopt_request(fd, sd); } if( HPMHooks.count.HP_clif_pAdopt_request_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAdopt_request_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22718,11 +22824,11 @@ void HP_clif_pAdopt_request(int fd, struct map_session_data *sd) { void HP_clif_pAdopt_reply(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pAdopt_reply_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_reply_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pAdopt_reply_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22733,10 +22839,10 @@ void HP_clif_pAdopt_reply(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pAdopt_reply(fd, sd); } if( HPMHooks.count.HP_clif_pAdopt_reply_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_reply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pAdopt_reply_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22744,11 +22850,11 @@ void HP_clif_pAdopt_reply(int fd, struct map_session_data *sd) { void HP_clif_pViewPlayerEquip(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pViewPlayerEquip_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22759,10 +22865,10 @@ void HP_clif_pViewPlayerEquip(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pViewPlayerEquip(fd, sd); } if( HPMHooks.count.HP_clif_pViewPlayerEquip_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22770,11 +22876,11 @@ void HP_clif_pViewPlayerEquip(int fd, struct map_session_data *sd) { void HP_clif_pEquipTick(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pEquipTick_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pEquipTick_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22785,10 +22891,10 @@ void HP_clif_pEquipTick(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pEquipTick(fd, sd); } if( HPMHooks.count.HP_clif_pEquipTick_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pEquipTick_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22796,11 +22902,11 @@ void HP_clif_pEquipTick(int fd, struct map_session_data *sd) { void HP_clif_pquestStateAck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pquestStateAck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pquestStateAck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22811,10 +22917,10 @@ void HP_clif_pquestStateAck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pquestStateAck(fd, sd); } if( HPMHooks.count.HP_clif_pquestStateAck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pquestStateAck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22822,11 +22928,11 @@ void HP_clif_pquestStateAck(int fd, struct map_session_data *sd) { void HP_clif_pmercenary_action(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pmercenary_action_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pmercenary_action_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pmercenary_action_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22837,10 +22943,10 @@ void HP_clif_pmercenary_action(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pmercenary_action(fd, sd); } if( HPMHooks.count.HP_clif_pmercenary_action_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pmercenary_action_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pmercenary_action_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22848,11 +22954,11 @@ void HP_clif_pmercenary_action(int fd, struct map_session_data *sd) { void HP_clif_pBattleChat(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBattleChat_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBattleChat_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22863,10 +22969,10 @@ void HP_clif_pBattleChat(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBattleChat(fd, sd); } if( HPMHooks.count.HP_clif_pBattleChat_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBattleChat_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22874,11 +22980,11 @@ void HP_clif_pBattleChat(int fd, struct map_session_data *sd) { void HP_clif_pLessEffect(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pLessEffect_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pLessEffect_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22889,10 +22995,10 @@ void HP_clif_pLessEffect(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pLessEffect(fd, sd); } if( HPMHooks.count.HP_clif_pLessEffect_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pLessEffect_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22900,11 +23006,11 @@ void HP_clif_pLessEffect(int fd, struct map_session_data *sd) { void HP_clif_pItemListWindowSelected(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pItemListWindowSelected_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22915,10 +23021,10 @@ void HP_clif_pItemListWindowSelected(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pItemListWindowSelected(fd, sd); } if( HPMHooks.count.HP_clif_pItemListWindowSelected_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22926,11 +23032,11 @@ void HP_clif_pItemListWindowSelected(int fd, struct map_session_data *sd) { void HP_clif_pReqOpenBuyingStore(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22941,10 +23047,10 @@ void HP_clif_pReqOpenBuyingStore(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReqOpenBuyingStore(fd, sd); } if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22952,11 +23058,11 @@ void HP_clif_pReqOpenBuyingStore(int fd, struct map_session_data *sd) { void HP_clif_pReqCloseBuyingStore(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22967,10 +23073,10 @@ void HP_clif_pReqCloseBuyingStore(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReqCloseBuyingStore(fd, sd); } if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -22978,11 +23084,11 @@ void HP_clif_pReqCloseBuyingStore(int fd, struct map_session_data *sd) { void HP_clif_pReqClickBuyingStore(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReqClickBuyingStore_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -22993,10 +23099,10 @@ void HP_clif_pReqClickBuyingStore(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReqClickBuyingStore(fd, sd); } if( HPMHooks.count.HP_clif_pReqClickBuyingStore_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23004,11 +23110,11 @@ void HP_clif_pReqClickBuyingStore(int fd, struct map_session_data *sd) { void HP_clif_pReqTradeBuyingStore(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23019,10 +23125,10 @@ void HP_clif_pReqTradeBuyingStore(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pReqTradeBuyingStore(fd, sd); } if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23030,11 +23136,11 @@ void HP_clif_pReqTradeBuyingStore(int fd, struct map_session_data *sd) { void HP_clif_pSearchStoreInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSearchStoreInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23045,10 +23151,10 @@ void HP_clif_pSearchStoreInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSearchStoreInfo(fd, sd); } if( HPMHooks.count.HP_clif_pSearchStoreInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23056,11 +23162,11 @@ void HP_clif_pSearchStoreInfo(int fd, struct map_session_data *sd) { void HP_clif_pSearchStoreInfoNextPage(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23071,10 +23177,10 @@ void HP_clif_pSearchStoreInfoNextPage(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSearchStoreInfoNextPage(fd, sd); } if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23082,11 +23188,11 @@ void HP_clif_pSearchStoreInfoNextPage(int fd, struct map_session_data *sd) { void HP_clif_pCloseSearchStoreInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23097,10 +23203,10 @@ void HP_clif_pCloseSearchStoreInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCloseSearchStoreInfo(fd, sd); } if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23108,11 +23214,11 @@ void HP_clif_pCloseSearchStoreInfo(int fd, struct map_session_data *sd) { void HP_clif_pSearchStoreInfoListItemClick(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23123,10 +23229,10 @@ void HP_clif_pSearchStoreInfoListItemClick(int fd, struct map_session_data *sd) HPMHooks.source.clif.pSearchStoreInfoListItemClick(fd, sd); } if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23134,11 +23240,11 @@ void HP_clif_pSearchStoreInfoListItemClick(int fd, struct map_session_data *sd) void HP_clif_pDebug(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pDebug_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pDebug_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23149,10 +23255,10 @@ void HP_clif_pDebug(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pDebug(fd, sd); } if( HPMHooks.count.HP_clif_pDebug_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pDebug_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23160,11 +23266,11 @@ void HP_clif_pDebug(int fd, struct map_session_data *sd) { void HP_clif_pSkillSelectMenu(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSkillSelectMenu_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23175,10 +23281,10 @@ void HP_clif_pSkillSelectMenu(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSkillSelectMenu(fd, sd); } if( HPMHooks.count.HP_clif_pSkillSelectMenu_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23186,11 +23292,11 @@ void HP_clif_pSkillSelectMenu(int fd, struct map_session_data *sd) { void HP_clif_pMoveItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pMoveItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pMoveItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23201,10 +23307,10 @@ void HP_clif_pMoveItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pMoveItem(fd, sd); } if( HPMHooks.count.HP_clif_pMoveItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pMoveItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23212,11 +23318,11 @@ void HP_clif_pMoveItem(int fd, struct map_session_data *sd) { void HP_clif_pDull(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pDull_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pDull_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23227,10 +23333,10 @@ void HP_clif_pDull(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pDull(fd, sd); } if( HPMHooks.count.HP_clif_pDull_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pDull_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23238,11 +23344,11 @@ void HP_clif_pDull(int fd, struct map_session_data *sd) { void HP_clif_pBGQueueRegister(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBGQueueRegister_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23253,10 +23359,10 @@ void HP_clif_pBGQueueRegister(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBGQueueRegister(fd, sd); } if( HPMHooks.count.HP_clif_pBGQueueRegister_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23264,11 +23370,11 @@ void HP_clif_pBGQueueRegister(int fd, struct map_session_data *sd) { void HP_clif_pBGQueueCheckState(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBGQueueCheckState_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23279,10 +23385,10 @@ void HP_clif_pBGQueueCheckState(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBGQueueCheckState(fd, sd); } if( HPMHooks.count.HP_clif_pBGQueueCheckState_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23290,11 +23396,11 @@ void HP_clif_pBGQueueCheckState(int fd, struct map_session_data *sd) { void HP_clif_pBGQueueRevokeReq(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23305,10 +23411,10 @@ void HP_clif_pBGQueueRevokeReq(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBGQueueRevokeReq(fd, sd); } if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23316,11 +23422,11 @@ void HP_clif_pBGQueueRevokeReq(int fd, struct map_session_data *sd) { void HP_clif_pBGQueueBattleBeginAck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23331,10 +23437,10 @@ void HP_clif_pBGQueueBattleBeginAck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBGQueueBattleBeginAck(fd, sd); } if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23342,11 +23448,11 @@ void HP_clif_pBGQueueBattleBeginAck(int fd, struct map_session_data *sd) { void HP_clif_pCashShopOpen(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCashShopOpen_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23357,10 +23463,10 @@ void HP_clif_pCashShopOpen(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCashShopOpen(fd, sd); } if( HPMHooks.count.HP_clif_pCashShopOpen_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23368,11 +23474,11 @@ void HP_clif_pCashShopOpen(int fd, struct map_session_data *sd) { void HP_clif_pCashShopClose(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCashShopClose_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCashShopClose_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23383,10 +23489,10 @@ void HP_clif_pCashShopClose(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCashShopClose(fd, sd); } if( HPMHooks.count.HP_clif_pCashShopClose_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCashShopClose_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23394,11 +23500,11 @@ void HP_clif_pCashShopClose(int fd, struct map_session_data *sd) { void HP_clif_pCashShopReqTab(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCashShopReqTab_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23409,10 +23515,10 @@ void HP_clif_pCashShopReqTab(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCashShopReqTab(fd, sd); } if( HPMHooks.count.HP_clif_pCashShopReqTab_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23420,11 +23526,11 @@ void HP_clif_pCashShopReqTab(int fd, struct map_session_data *sd) { void HP_clif_pCashShopSchedule(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCashShopSchedule_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23435,10 +23541,10 @@ void HP_clif_pCashShopSchedule(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCashShopSchedule(fd, sd); } if( HPMHooks.count.HP_clif_pCashShopSchedule_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23446,11 +23552,11 @@ void HP_clif_pCashShopSchedule(int fd, struct map_session_data *sd) { void HP_clif_pCashShopBuy(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pCashShopBuy_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23461,10 +23567,10 @@ void HP_clif_pCashShopBuy(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pCashShopBuy(fd, sd); } if( HPMHooks.count.HP_clif_pCashShopBuy_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23472,11 +23578,11 @@ void HP_clif_pCashShopBuy(int fd, struct map_session_data *sd) { void HP_clif_pPartyTick(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyTick_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyTick_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23487,10 +23593,10 @@ void HP_clif_pPartyTick(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyTick(fd, sd); } if( HPMHooks.count.HP_clif_pPartyTick_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyTick_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23498,11 +23604,11 @@ void HP_clif_pPartyTick(int fd, struct map_session_data *sd) { void HP_clif_pGuildInvite2(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pGuildInvite2_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23513,10 +23619,10 @@ void HP_clif_pGuildInvite2(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pGuildInvite2(fd, sd); } if( HPMHooks.count.HP_clif_pGuildInvite2_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23524,11 +23630,11 @@ void HP_clif_pGuildInvite2(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingAddFilter(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23539,10 +23645,10 @@ void HP_clif_pPartyBookingAddFilter(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingAddFilter(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23550,11 +23656,11 @@ void HP_clif_pPartyBookingAddFilter(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingSubFilter(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23565,10 +23671,10 @@ void HP_clif_pPartyBookingSubFilter(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingSubFilter(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23576,11 +23682,11 @@ void HP_clif_pPartyBookingSubFilter(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingReqVolunteer(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23591,10 +23697,10 @@ void HP_clif_pPartyBookingReqVolunteer(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingReqVolunteer(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23602,11 +23708,11 @@ void HP_clif_pPartyBookingReqVolunteer(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingRefuseVolunteer(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23617,10 +23723,10 @@ void HP_clif_pPartyBookingRefuseVolunteer(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingRefuseVolunteer(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23628,11 +23734,11 @@ void HP_clif_pPartyBookingRefuseVolunteer(int fd, struct map_session_data *sd) { void HP_clif_pPartyBookingCancelVolunteer(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23643,10 +23749,10 @@ void HP_clif_pPartyBookingCancelVolunteer(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pPartyBookingCancelVolunteer(fd, sd); } if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23654,11 +23760,11 @@ void HP_clif_pPartyBookingCancelVolunteer(int fd, struct map_session_data *sd) { void HP_clif_pBankDeposit(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBankDeposit_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankDeposit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBankDeposit_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23669,10 +23775,10 @@ void HP_clif_pBankDeposit(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBankDeposit(fd, sd); } if( HPMHooks.count.HP_clif_pBankDeposit_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankDeposit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBankDeposit_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23680,11 +23786,11 @@ void HP_clif_pBankDeposit(int fd, struct map_session_data *sd) { void HP_clif_pBankWithdraw(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBankWithdraw_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankWithdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBankWithdraw_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23695,10 +23801,10 @@ void HP_clif_pBankWithdraw(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBankWithdraw(fd, sd); } if( HPMHooks.count.HP_clif_pBankWithdraw_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankWithdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBankWithdraw_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23706,11 +23812,11 @@ void HP_clif_pBankWithdraw(int fd, struct map_session_data *sd) { void HP_clif_pBankCheck(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBankCheck_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankCheck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBankCheck_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23721,10 +23827,10 @@ void HP_clif_pBankCheck(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBankCheck(fd, sd); } if( HPMHooks.count.HP_clif_pBankCheck_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankCheck_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBankCheck_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23732,11 +23838,11 @@ void HP_clif_pBankCheck(int fd, struct map_session_data *sd) { void HP_clif_pBankOpen(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBankOpen_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankOpen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBankOpen_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23747,10 +23853,10 @@ void HP_clif_pBankOpen(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBankOpen(fd, sd); } if( HPMHooks.count.HP_clif_pBankOpen_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankOpen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBankOpen_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23758,11 +23864,11 @@ void HP_clif_pBankOpen(int fd, struct map_session_data *sd) { void HP_clif_pBankClose(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pBankClose_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankClose_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pBankClose_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23773,10 +23879,10 @@ void HP_clif_pBankClose(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pBankClose(fd, sd); } if( HPMHooks.count.HP_clif_pBankClose_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankClose_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pBankClose_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23784,11 +23890,11 @@ void HP_clif_pBankClose(int fd, struct map_session_data *sd) { void HP_clif_pRouletteOpen(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRouletteOpen_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteOpen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRouletteOpen_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23799,10 +23905,10 @@ void HP_clif_pRouletteOpen(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRouletteOpen(fd, sd); } if( HPMHooks.count.HP_clif_pRouletteOpen_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteOpen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRouletteOpen_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23810,11 +23916,11 @@ void HP_clif_pRouletteOpen(int fd, struct map_session_data *sd) { void HP_clif_pRouletteInfo(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRouletteInfo_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteInfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRouletteInfo_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23825,10 +23931,10 @@ void HP_clif_pRouletteInfo(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRouletteInfo(fd, sd); } if( HPMHooks.count.HP_clif_pRouletteInfo_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRouletteInfo_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23836,11 +23942,11 @@ void HP_clif_pRouletteInfo(int fd, struct map_session_data *sd) { void HP_clif_pRouletteClose(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRouletteClose_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteClose_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRouletteClose_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23851,10 +23957,10 @@ void HP_clif_pRouletteClose(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRouletteClose(fd, sd); } if( HPMHooks.count.HP_clif_pRouletteClose_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteClose_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRouletteClose_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23862,11 +23968,11 @@ void HP_clif_pRouletteClose(int fd, struct map_session_data *sd) { void HP_clif_pRouletteGenerate(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRouletteGenerate_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteGenerate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRouletteGenerate_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23877,10 +23983,10 @@ void HP_clif_pRouletteGenerate(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRouletteGenerate(fd, sd); } if( HPMHooks.count.HP_clif_pRouletteGenerate_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteGenerate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRouletteGenerate_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23888,11 +23994,11 @@ void HP_clif_pRouletteGenerate(int fd, struct map_session_data *sd) { void HP_clif_pRouletteRecvItem(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pRouletteRecvItem_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteRecvItem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pRouletteRecvItem_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23903,10 +24009,10 @@ void HP_clif_pRouletteRecvItem(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pRouletteRecvItem(fd, sd); } if( HPMHooks.count.HP_clif_pRouletteRecvItem_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteRecvItem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pRouletteRecvItem_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23914,11 +24020,11 @@ void HP_clif_pRouletteRecvItem(int fd, struct map_session_data *sd) { void HP_clif_pNPCShopClosed(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNPCShopClosed_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCShopClosed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNPCShopClosed_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23929,10 +24035,10 @@ void HP_clif_pNPCShopClosed(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNPCShopClosed(fd, sd); } if( HPMHooks.count.HP_clif_pNPCShopClosed_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCShopClosed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNPCShopClosed_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23940,11 +24046,11 @@ void HP_clif_pNPCShopClosed(int fd, struct map_session_data *sd) { void HP_clif_pNPCMarketClosed(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNPCMarketClosed_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketClosed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNPCMarketClosed_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23955,10 +24061,10 @@ void HP_clif_pNPCMarketClosed(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNPCMarketClosed(fd, sd); } if( HPMHooks.count.HP_clif_pNPCMarketClosed_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketClosed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNPCMarketClosed_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23966,11 +24072,11 @@ void HP_clif_pNPCMarketClosed(int fd, struct map_session_data *sd) { void HP_clif_pNPCMarketPurchase(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pNPCMarketPurchase_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketPurchase_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pNPCMarketPurchase_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -23981,10 +24087,10 @@ void HP_clif_pNPCMarketPurchase(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pNPCMarketPurchase(fd, sd); } if( HPMHooks.count.HP_clif_pNPCMarketPurchase_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketPurchase_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pNPCMarketPurchase_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -23992,11 +24098,11 @@ void HP_clif_pNPCMarketPurchase(int fd, struct map_session_data *sd) { void HP_clif_add_random_options(unsigned char *buf, struct item *item) { int hIndex = 0; if( HPMHooks.count.HP_clif_add_random_options_pre ) { - void (*preHookFunc) (unsigned char *buf, struct item *item); + void (*preHookFunc) (unsigned char **buf, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_add_random_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_add_random_options_pre[hIndex].func; - preHookFunc(buf, item); + preHookFunc(&buf, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24018,11 +24124,11 @@ void HP_clif_add_random_options(unsigned char *buf, struct item *item) { void HP_clif_pHotkeyRowShift(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pHotkeyRowShift_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkeyRowShift_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pHotkeyRowShift_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24033,10 +24139,10 @@ void HP_clif_pHotkeyRowShift(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pHotkeyRowShift(fd, sd); } if( HPMHooks.count.HP_clif_pHotkeyRowShift_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkeyRowShift_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pHotkeyRowShift_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -24044,11 +24150,11 @@ void HP_clif_pHotkeyRowShift(int fd, struct map_session_data *sd) { void HP_clif_dressroom_open(struct map_session_data *sd, int view) { int hIndex = 0; if( HPMHooks.count.HP_clif_dressroom_open_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *view); + void (*preHookFunc) (struct map_session_data **sd, int *view); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dressroom_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_dressroom_open_pre[hIndex].func; - preHookFunc(sd, &view); + preHookFunc(&sd, &view); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24059,10 +24165,10 @@ void HP_clif_dressroom_open(struct map_session_data *sd, int view) { HPMHooks.source.clif.dressroom_open(sd, view); } if( HPMHooks.count.HP_clif_dressroom_open_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *view); + void (*postHookFunc) (struct map_session_data *sd, int view); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dressroom_open_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_dressroom_open_post[hIndex].func; - postHookFunc(sd, &view); + postHookFunc(sd, view); } } return; @@ -24070,11 +24176,11 @@ void HP_clif_dressroom_open(struct map_session_data *sd, int view) { void HP_clif_pOneClick_ItemIdentify(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pOneClick_ItemIdentify_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOneClick_ItemIdentify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pOneClick_ItemIdentify_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24085,10 +24191,10 @@ void HP_clif_pOneClick_ItemIdentify(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pOneClick_ItemIdentify(fd, sd); } if( HPMHooks.count.HP_clif_pOneClick_ItemIdentify_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOneClick_ItemIdentify_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pOneClick_ItemIdentify_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -24096,11 +24202,11 @@ void HP_clif_pOneClick_ItemIdentify(int fd, struct map_session_data *sd) { void HP_clif_selectcart(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_selectcart_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selectcart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_selectcart_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24122,11 +24228,11 @@ void HP_clif_selectcart(struct map_session_data *sd) { void HP_clif_pSelectCart(int fd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_clif_pSelectCart_pre ) { - void (*preHookFunc) (int *fd, struct map_session_data *sd); + void (*preHookFunc) (int *fd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectCart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_pSelectCart_pre[hIndex].func; - preHookFunc(&fd, sd); + preHookFunc(&fd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24137,10 +24243,10 @@ void HP_clif_pSelectCart(int fd, struct map_session_data *sd) { HPMHooks.source.clif.pSelectCart(fd, sd); } if( HPMHooks.count.HP_clif_pSelectCart_post ) { - void (*postHookFunc) (int *fd, struct map_session_data *sd); + void (*postHookFunc) (int fd, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectCart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_clif_pSelectCart_post[hIndex].func; - postHookFunc(&fd, sd); + postHookFunc(fd, sd); } } return; @@ -24149,11 +24255,11 @@ const char* HP_clif_get_bl_name(const struct block_list *bl) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_clif_get_bl_name_pre ) { - const char* (*preHookFunc) (const struct block_list *bl); + const char* (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_bl_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_clif_get_bl_name_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24229,11 +24335,11 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_add_pre ) { - bool (*preHookFunc) (unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*preHookFunc) (unsigned int *pluginID, const char **name, char *shortname, CmdlineExecFunc *func, const char **help, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func; - retVal___ = preHookFunc(&pluginID, name, &shortname, &func, help, &options); + retVal___ = preHookFunc(&pluginID, &name, &shortname, &func, &help, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24244,10 +24350,10 @@ bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options); } if( HPMHooks.count.HP_cmdline_arg_add_post ) { - bool (*postHookFunc) (bool retVal___, unsigned int *pluginID, const char *name, char *shortname, CmdlineExecFunc *func, const char *help, unsigned int *options); + bool (*postHookFunc) (bool retVal___, unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pluginID, name, &shortname, &func, help, &options); + retVal___ = postHookFunc(retVal___, pluginID, name, shortname, func, help, options); } } return retVal___; @@ -24256,11 +24362,11 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_cmdline_exec_pre ) { - int (*preHookFunc) (int *argc, char **argv, unsigned int *options); + int (*preHookFunc) (int *argc, char ***argv, unsigned int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func; - retVal___ = preHookFunc(&argc, argv, &options); + retVal___ = preHookFunc(&argc, &argv, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24271,10 +24377,10 @@ int HP_cmdline_exec(int argc, char **argv, unsigned int options) { retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options); } if( HPMHooks.count.HP_cmdline_exec_post ) { - int (*postHookFunc) (int retVal___, int *argc, char **argv, unsigned int *options); + int (*postHookFunc) (int retVal___, int argc, char **argv, unsigned int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &argc, argv, &options); + retVal___ = postHookFunc(retVal___, argc, argv, options); } } return retVal___; @@ -24283,11 +24389,11 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) { - bool (*preHookFunc) (const char *name, int *current_arg, int *argc); + bool (*preHookFunc) (const char **name, int *current_arg, int *argc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func; - retVal___ = preHookFunc(name, ¤t_arg, &argc); + retVal___ = preHookFunc(&name, ¤t_arg, &argc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24298,10 +24404,10 @@ bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) { retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc); } if( HPMHooks.count.HP_cmdline_arg_next_value_post ) { - bool (*postHookFunc) (bool retVal___, const char *name, int *current_arg, int *argc); + bool (*postHookFunc) (bool retVal___, const char *name, int current_arg, int argc); for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, ¤t_arg, &argc); + retVal___ = postHookFunc(retVal___, name, current_arg, argc); } } return retVal___; @@ -24310,11 +24416,11 @@ const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_cmdline_arg_source_pre ) { - const char* (*preHookFunc) (struct CmdlineArgData *arg); + const char* (*preHookFunc) (struct CmdlineArgData **arg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func; - retVal___ = preHookFunc(arg); + retVal___ = preHookFunc(&arg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24485,10 +24591,10 @@ enum DBOptions HP_DB_fix_options(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.fix_options(type, options); } if( HPMHooks.count.HP_DB_fix_options_post ) { - enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType *type, enum DBOptions *options); + enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -24512,10 +24618,10 @@ DBComparator HP_DB_default_cmp(enum DBType type) { retVal___ = HPMHooks.source.DB.default_cmp(type); } if( HPMHooks.count.HP_DB_default_cmp_post ) { - DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType *type); + DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -24539,10 +24645,10 @@ DBHasher HP_DB_default_hash(enum DBType type) { retVal___ = HPMHooks.source.DB.default_hash(type); } if( HPMHooks.count.HP_DB_default_hash_post ) { - DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType *type); + DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType type); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -24566,10 +24672,10 @@ DBReleaser HP_DB_default_release(enum DBType type, enum DBOptions options) { retVal___ = HPMHooks.source.DB.default_release(type, options); } if( HPMHooks.count.HP_DB_default_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType *type, enum DBOptions *options); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType type, enum DBOptions options); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &options); + retVal___ = postHookFunc(retVal___, type, options); } } return retVal___; @@ -24593,10 +24699,10 @@ DBReleaser HP_DB_custom_release(enum DBReleaseOption which) { retVal___ = HPMHooks.source.DB.custom_release(which); } if( HPMHooks.count.HP_DB_custom_release_post ) { - DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption *which); + DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption which); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &which); + retVal___ = postHookFunc(retVal___, which); } } return retVal___; @@ -24605,11 +24711,11 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT int hIndex = 0; struct DBMap* retVal___ = NULL; if( HPMHooks.count.HP_DB_alloc_pre ) { - struct DBMap* (*preHookFunc) (const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*preHookFunc) (const char **file, const char **func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func; - retVal___ = preHookFunc(file, func, &line, &type, &options, &maxlen); + retVal___ = preHookFunc(&file, &func, &line, &type, &options, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24620,18 +24726,17 @@ struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBT retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen); } if( HPMHooks.count.HP_DB_alloc_post ) { - struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen); + struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, file, func, &line, &type, &options, &maxlen); + retVal___ = postHookFunc(retVal___, file, func, line, type, options, maxlen); } } return retVal___; } union DBKey HP_DB_i2key(int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2key_pre ) { union DBKey (*preHookFunc) (int *key); *HPMforce_return = false; @@ -24648,18 +24753,17 @@ union DBKey HP_DB_i2key(int key) { retVal___ = HPMHooks.source.DB.i2key(key); } if( HPMHooks.count.HP_DB_i2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui2key(unsigned int key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2key_pre ) { union DBKey (*preHookFunc) (unsigned int *key); *HPMforce_return = false; @@ -24676,24 +24780,23 @@ union DBKey HP_DB_ui2key(unsigned int key) { retVal___ = HPMHooks.source.DB.ui2key(key); } if( HPMHooks.count.HP_DB_ui2key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int *key); + union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_str2key(const char *key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_str2key_pre ) { - union DBKey (*preHookFunc) (const char *key); + union DBKey (*preHookFunc) (const char **key); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func; - retVal___ = preHookFunc(key); + retVal___ = preHookFunc(&key); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24714,8 +24817,7 @@ union DBKey HP_DB_str2key(const char *key) { } union DBKey HP_DB_i642key(int64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i642key_pre ) { union DBKey (*preHookFunc) (int64 *key); *HPMforce_return = false; @@ -24732,18 +24834,17 @@ union DBKey HP_DB_i642key(int64 key) { retVal___ = HPMHooks.source.DB.i642key(key); } if( HPMHooks.count.HP_DB_i642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, int64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, int64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } union DBKey HP_DB_ui642key(uint64 key) { int hIndex = 0; - union DBKey retVal___; - memset(&retVal___, '\0', sizeof(union DBKey)); + union DBKey retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui642key_pre ) { union DBKey (*preHookFunc) (uint64 *key); *HPMforce_return = false; @@ -24760,18 +24861,17 @@ union DBKey HP_DB_ui642key(uint64 key) { retVal___ = HPMHooks.source.DB.ui642key(key); } if( HPMHooks.count.HP_DB_ui642key_post ) { - union DBKey (*postHookFunc) (union DBKey retVal___, uint64 *key); + union DBKey (*postHookFunc) (union DBKey retVal___, uint64 key); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key); + retVal___ = postHookFunc(retVal___, key); } } return retVal___; } struct DBData HP_DB_i2data(int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_i2data_pre ) { struct DBData (*preHookFunc) (int *data); *HPMforce_return = false; @@ -24788,18 +24888,17 @@ struct DBData HP_DB_i2data(int data) { retVal___ = HPMHooks.source.DB.i2data(data); } if( HPMHooks.count.HP_DB_i2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ui2data(unsigned int data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ui2data_pre ) { struct DBData (*preHookFunc) (unsigned int *data); *HPMforce_return = false; @@ -24816,24 +24915,23 @@ struct DBData HP_DB_ui2data(unsigned int data) { retVal___ = HPMHooks.source.DB.ui2data(data); } if( HPMHooks.count.HP_DB_ui2data_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int *data); + struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int data); for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &data); + retVal___ = postHookFunc(retVal___, data); } } return retVal___; } struct DBData HP_DB_ptr2data(void *data) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_DB_ptr2data_pre ) { - struct DBData (*preHookFunc) (void *data); + struct DBData (*preHookFunc) (void **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24856,11 +24954,11 @@ int HP_DB_data2i(struct DBData *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_DB_data2i_pre ) { - int (*preHookFunc) (struct DBData *data); + int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24883,11 +24981,11 @@ unsigned int HP_DB_data2ui(struct DBData *data) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_DB_data2ui_pre ) { - unsigned int (*preHookFunc) (struct DBData *data); + unsigned int (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24910,11 +25008,11 @@ void* HP_DB_data2ptr(struct DBData *data) { int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_DB_data2ptr_pre ) { - void* (*preHookFunc) (struct DBData *data); + void* (*preHookFunc) (struct DBData **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -24990,11 +25088,11 @@ int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_duel_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const unsigned int *maxpl); + int (*preHookFunc) (struct map_session_data **sd, const unsigned int *maxpl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, &maxpl); + retVal___ = preHookFunc(&sd, &maxpl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25005,10 +25103,10 @@ int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) { retVal___ = HPMHooks.source.duel.create(sd, maxpl); } if( HPMHooks.count.HP_duel_create_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const unsigned int *maxpl); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const unsigned int maxpl); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &maxpl); + retVal___ = postHookFunc(retVal___, sd, maxpl); } } return retVal___; @@ -25016,11 +25114,11 @@ int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) { void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd) { int hIndex = 0; if( HPMHooks.count.HP_duel_invite_pre ) { - void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd, struct map_session_data *target_sd); + void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd, struct map_session_data **target_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_invite_pre[hIndex].func; - preHookFunc(&did, sd, target_sd); + preHookFunc(&did, &sd, &target_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25031,10 +25129,10 @@ void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct HPMHooks.source.duel.invite(did, sd, target_sd); } if( HPMHooks.count.HP_duel_invite_post ) { - void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd, struct map_session_data *target_sd); + void (*postHookFunc) (const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_invite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_invite_post[hIndex].func; - postHookFunc(&did, sd, target_sd); + postHookFunc(did, sd, target_sd); } } return; @@ -25042,11 +25140,11 @@ void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct void HP_duel_accept(const unsigned int did, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_duel_accept_pre ) { - void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_accept_pre[hIndex].func; - preHookFunc(&did, sd); + preHookFunc(&did, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25057,10 +25155,10 @@ void HP_duel_accept(const unsigned int did, struct map_session_data *sd) { HPMHooks.source.duel.accept(did, sd); } if( HPMHooks.count.HP_duel_accept_post ) { - void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*postHookFunc) (const unsigned int did, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_accept_post[hIndex].func; - postHookFunc(&did, sd); + postHookFunc(did, sd); } } return; @@ -25068,11 +25166,11 @@ void HP_duel_accept(const unsigned int did, struct map_session_data *sd) { void HP_duel_reject(const unsigned int did, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_duel_reject_pre ) { - void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_reject_pre[hIndex].func; - preHookFunc(&did, sd); + preHookFunc(&did, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25083,10 +25181,10 @@ void HP_duel_reject(const unsigned int did, struct map_session_data *sd) { HPMHooks.source.duel.reject(did, sd); } if( HPMHooks.count.HP_duel_reject_post ) { - void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*postHookFunc) (const unsigned int did, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_reject_post[hIndex].func; - postHookFunc(&did, sd); + postHookFunc(did, sd); } } return; @@ -25094,11 +25192,11 @@ void HP_duel_reject(const unsigned int did, struct map_session_data *sd) { void HP_duel_leave(const unsigned int did, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_duel_leave_pre ) { - void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_leave_pre[hIndex].func; - preHookFunc(&did, sd); + preHookFunc(&did, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25109,10 +25207,10 @@ void HP_duel_leave(const unsigned int did, struct map_session_data *sd) { HPMHooks.source.duel.leave(did, sd); } if( HPMHooks.count.HP_duel_leave_post ) { - void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*postHookFunc) (const unsigned int did, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_leave_post[hIndex].func; - postHookFunc(&did, sd); + postHookFunc(did, sd); } } return; @@ -25120,11 +25218,11 @@ void HP_duel_leave(const unsigned int did, struct map_session_data *sd) { void HP_duel_showinfo(const unsigned int did, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_duel_showinfo_pre ) { - void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_showinfo_pre[hIndex].func; - preHookFunc(&did, sd); + preHookFunc(&did, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25135,10 +25233,10 @@ void HP_duel_showinfo(const unsigned int did, struct map_session_data *sd) { HPMHooks.source.duel.showinfo(did, sd); } if( HPMHooks.count.HP_duel_showinfo_post ) { - void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd); + void (*postHookFunc) (const unsigned int did, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_duel_showinfo_post[hIndex].func; - postHookFunc(&did, sd); + postHookFunc(did, sd); } } return; @@ -25147,11 +25245,11 @@ int HP_duel_checktime(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_duel_checktime_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_checktime_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_duel_checktime_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25188,10 +25286,10 @@ void HP_duel_init(bool minimal) { HPMHooks.source.duel.init(minimal); } if( HPMHooks.count.HP_duel_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -25242,10 +25340,10 @@ int HP_elemental_init(bool minimal) { retVal___ = HPMHooks.source.elemental.init(minimal); } if( HPMHooks.count.HP_elemental_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -25295,10 +25393,10 @@ bool HP_elemental_class(int class_) { retVal___ = HPMHooks.source.elemental.class(class_); } if( HPMHooks.count.HP_elemental_class_post ) { - bool (*postHookFunc) (bool retVal___, int *class_); + bool (*postHookFunc) (bool retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_class_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_class_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -25322,10 +25420,10 @@ struct view_data* HP_elemental_get_viewdata(int class_) { retVal___ = HPMHooks.source.elemental.get_viewdata(class_); } if( HPMHooks.count.HP_elemental_get_viewdata_post ) { - struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_); + struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_get_viewdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -25334,11 +25432,11 @@ int HP_elemental_create(struct map_session_data *sd, int class_, unsigned int li int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime); + int (*preHookFunc) (struct map_session_data **sd, int *class_, unsigned int *lifetime); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, &class_, &lifetime); + retVal___ = preHookFunc(&sd, &class_, &lifetime); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25349,10 +25447,10 @@ int HP_elemental_create(struct map_session_data *sd, int class_, unsigned int li retVal___ = HPMHooks.source.elemental.create(sd, class_, lifetime); } if( HPMHooks.count.HP_elemental_create_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_, unsigned int *lifetime); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &class_, &lifetime); + retVal___ = postHookFunc(retVal___, sd, class_, lifetime); } } return retVal___; @@ -25361,11 +25459,11 @@ int HP_elemental_data_received(const struct s_elemental *ele, bool flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_data_received_pre ) { - int (*preHookFunc) (const struct s_elemental *ele, bool *flag); + int (*preHookFunc) (const struct s_elemental **ele, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_data_received_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_data_received_pre[hIndex].func; - retVal___ = preHookFunc(ele, &flag); + retVal___ = preHookFunc(&ele, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25376,10 +25474,10 @@ int HP_elemental_data_received(const struct s_elemental *ele, bool flag) { retVal___ = HPMHooks.source.elemental.data_received(ele, flag); } if( HPMHooks.count.HP_elemental_data_received_post ) { - int (*postHookFunc) (int retVal___, const struct s_elemental *ele, bool *flag); + int (*postHookFunc) (int retVal___, const struct s_elemental *ele, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_data_received_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_data_received_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ele, &flag); + retVal___ = postHookFunc(retVal___, ele, flag); } } return retVal___; @@ -25388,11 +25486,11 @@ int HP_elemental_save(struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_save_pre ) { - int (*preHookFunc) (struct elemental_data *ed); + int (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_save_pre[hIndex].func; - retVal___ = preHookFunc(ed); + retVal___ = preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25415,11 +25513,11 @@ int HP_elemental_change_mode_ack(struct elemental_data *ed, int mode) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_change_mode_ack_pre ) { - int (*preHookFunc) (struct elemental_data *ed, int *mode); + int (*preHookFunc) (struct elemental_data **ed, int *mode); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_change_mode_ack_pre[hIndex].func; - retVal___ = preHookFunc(ed, &mode); + retVal___ = preHookFunc(&ed, &mode); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25430,10 +25528,10 @@ int HP_elemental_change_mode_ack(struct elemental_data *ed, int mode) { retVal___ = HPMHooks.source.elemental.change_mode_ack(ed, mode); } if( HPMHooks.count.HP_elemental_change_mode_ack_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, int *mode); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, int mode); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_change_mode_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, &mode); + retVal___ = postHookFunc(retVal___, ed, mode); } } return retVal___; @@ -25442,11 +25540,11 @@ int HP_elemental_change_mode(struct elemental_data *ed, uint32 mode) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_change_mode_pre ) { - int (*preHookFunc) (struct elemental_data *ed, uint32 *mode); + int (*preHookFunc) (struct elemental_data **ed, uint32 *mode); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_change_mode_pre[hIndex].func; - retVal___ = preHookFunc(ed, &mode); + retVal___ = preHookFunc(&ed, &mode); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25457,10 +25555,10 @@ int HP_elemental_change_mode(struct elemental_data *ed, uint32 mode) { retVal___ = HPMHooks.source.elemental.change_mode(ed, mode); } if( HPMHooks.count.HP_elemental_change_mode_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint32 *mode); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint32 mode); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_change_mode_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, &mode); + retVal___ = postHookFunc(retVal___, ed, mode); } } return retVal___; @@ -25468,11 +25566,11 @@ int HP_elemental_change_mode(struct elemental_data *ed, uint32 mode) { void HP_elemental_heal(struct elemental_data *ed, int hp, int sp) { int hIndex = 0; if( HPMHooks.count.HP_elemental_heal_pre ) { - void (*preHookFunc) (struct elemental_data *ed, int *hp, int *sp); + void (*preHookFunc) (struct elemental_data **ed, int *hp, int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_heal_pre[hIndex].func; - preHookFunc(ed, &hp, &sp); + preHookFunc(&ed, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25483,10 +25581,10 @@ void HP_elemental_heal(struct elemental_data *ed, int hp, int sp) { HPMHooks.source.elemental.heal(ed, hp, sp); } if( HPMHooks.count.HP_elemental_heal_post ) { - void (*postHookFunc) (struct elemental_data *ed, int *hp, int *sp); + void (*postHookFunc) (struct elemental_data *ed, int hp, int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_heal_post[hIndex].func; - postHookFunc(ed, &hp, &sp); + postHookFunc(ed, hp, sp); } } return; @@ -25495,11 +25593,11 @@ int HP_elemental_dead(struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_dead_pre ) { - int (*preHookFunc) (struct elemental_data *ed); + int (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_dead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_dead_pre[hIndex].func; - retVal___ = preHookFunc(ed); + retVal___ = preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25522,11 +25620,11 @@ int HP_elemental_delete(struct elemental_data *ed, int reply) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_delete_pre ) { - int (*preHookFunc) (struct elemental_data *ed, int *reply); + int (*preHookFunc) (struct elemental_data **ed, int *reply); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_delete_pre[hIndex].func; - retVal___ = preHookFunc(ed, &reply); + retVal___ = preHookFunc(&ed, &reply); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25537,10 +25635,10 @@ int HP_elemental_delete(struct elemental_data *ed, int reply) { retVal___ = HPMHooks.source.elemental.delete(ed, reply); } if( HPMHooks.count.HP_elemental_delete_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, int *reply); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, int reply); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, &reply); + retVal___ = postHookFunc(retVal___, ed, reply); } } return retVal___; @@ -25548,11 +25646,11 @@ int HP_elemental_delete(struct elemental_data *ed, int reply) { void HP_elemental_summon_stop(struct elemental_data *ed) { int hIndex = 0; if( HPMHooks.count.HP_elemental_summon_stop_pre ) { - void (*preHookFunc) (struct elemental_data *ed); + void (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_stop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_summon_stop_pre[hIndex].func; - preHookFunc(ed); + preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25575,11 +25673,11 @@ int HP_elemental_get_lifetime(struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_get_lifetime_pre ) { - int (*preHookFunc) (struct elemental_data *ed); + int (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_lifetime_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_get_lifetime_pre[hIndex].func; - retVal___ = preHookFunc(ed); + retVal___ = preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25602,11 +25700,11 @@ int HP_elemental_unlocktarget(struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_unlocktarget_pre ) { - int (*preHookFunc) (struct elemental_data *ed); + int (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_unlocktarget_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_unlocktarget_pre[hIndex].func; - retVal___ = preHookFunc(ed); + retVal___ = preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25629,11 +25727,11 @@ int HP_elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_skillnotok_pre ) { - int (*preHookFunc) (uint16 *skill_id, struct elemental_data *ed); + int (*preHookFunc) (uint16 *skill_id, struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skillnotok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_skillnotok_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, ed); + retVal___ = preHookFunc(&skill_id, &ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25644,10 +25742,10 @@ int HP_elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) { retVal___ = HPMHooks.source.elemental.skillnotok(skill_id, ed); } if( HPMHooks.count.HP_elemental_skillnotok_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, struct elemental_data *ed); + int (*postHookFunc) (int retVal___, uint16 skill_id, struct elemental_data *ed); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skillnotok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_skillnotok_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, ed); + retVal___ = postHookFunc(retVal___, skill_id, ed); } } return retVal___; @@ -25656,11 +25754,11 @@ int HP_elemental_set_target(struct map_session_data *sd, struct block_list *bl) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_set_target_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_set_target_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_set_target_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl); + retVal___ = preHookFunc(&sd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25683,11 +25781,11 @@ int HP_elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_clean_single_effect_pre ) { - int (*preHookFunc) (struct elemental_data *ed, uint16 *skill_id); + int (*preHookFunc) (struct elemental_data **ed, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_single_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_clean_single_effect_pre[hIndex].func; - retVal___ = preHookFunc(ed, &skill_id); + retVal___ = preHookFunc(&ed, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25698,10 +25796,10 @@ int HP_elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id) retVal___ = HPMHooks.source.elemental.clean_single_effect(ed, skill_id); } if( HPMHooks.count.HP_elemental_clean_single_effect_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_single_effect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_clean_single_effect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, &skill_id); + retVal___ = postHookFunc(retVal___, ed, skill_id); } } return retVal___; @@ -25710,11 +25808,11 @@ int HP_elemental_clean_effect(struct elemental_data *ed) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_clean_effect_pre ) { - int (*preHookFunc) (struct elemental_data *ed); + int (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_clean_effect_pre[hIndex].func; - retVal___ = preHookFunc(ed); + retVal___ = preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25737,11 +25835,11 @@ int HP_elemental_action(struct elemental_data *ed, struct block_list *bl, int64 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_action_pre ) { - int (*preHookFunc) (struct elemental_data *ed, struct block_list *bl, int64 *tick); + int (*preHookFunc) (struct elemental_data **ed, struct block_list **bl, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_action_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_action_pre[hIndex].func; - retVal___ = preHookFunc(ed, bl, &tick); + retVal___ = preHookFunc(&ed, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25752,18 +25850,17 @@ int HP_elemental_action(struct elemental_data *ed, struct block_list *bl, int64 retVal___ = HPMHooks.source.elemental.action(ed, bl, tick); } if( HPMHooks.count.HP_elemental_action_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct block_list *bl, int64 *tick); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct block_list *bl, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_action_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_action_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, bl, &tick); + retVal___ = postHookFunc(retVal___, ed, bl, tick); } } return retVal___; } struct skill_condition HP_elemental_skill_get_requirements(uint16 skill_id, uint16 skill_lv) { int hIndex = 0; - struct skill_condition retVal___; - memset(&retVal___, '\0', sizeof(struct skill_condition)); + struct skill_condition retVal___ = { 0 }; if( HPMHooks.count.HP_elemental_skill_get_requirements_pre ) { struct skill_condition (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; @@ -25780,10 +25877,10 @@ struct skill_condition HP_elemental_skill_get_requirements(uint16 skill_id, uint retVal___ = HPMHooks.source.elemental.skill_get_requirements(skill_id, skill_lv); } if( HPMHooks.count.HP_elemental_skill_get_requirements_post ) { - struct skill_condition (*postHookFunc) (struct skill_condition retVal___, uint16 *skill_id, uint16 *skill_lv); + struct skill_condition (*postHookFunc) (struct skill_condition retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skill_get_requirements_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_skill_get_requirements_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -25886,10 +25983,10 @@ int HP_elemental_search_index(int class_) { retVal___ = HPMHooks.source.elemental.search_index(class_); } if( HPMHooks.count.HP_elemental_search_index_post ) { - int (*postHookFunc) (int retVal___, int *class_); + int (*postHookFunc) (int retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_search_index_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_search_index_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -25897,11 +25994,11 @@ int HP_elemental_search_index(int class_) { void HP_elemental_summon_init(struct elemental_data *ed) { int hIndex = 0; if( HPMHooks.count.HP_elemental_summon_init_pre ) { - void (*preHookFunc) (struct elemental_data *ed); + void (*preHookFunc) (struct elemental_data **ed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_summon_init_pre[hIndex].func; - preHookFunc(ed); + preHookFunc(&ed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25939,10 +26036,10 @@ int HP_elemental_summon_end_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.elemental.summon_end_timer(tid, tick, id, data); } if( HPMHooks.count.HP_elemental_summon_end_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_end_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_summon_end_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -25951,12 +26048,12 @@ int HP_elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_activesearch_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -25984,11 +26081,11 @@ int HP_elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_ai_sub_timer_pre ) { - int (*preHookFunc) (struct elemental_data *ed, struct map_session_data *sd, int64 *tick); + int (*preHookFunc) (struct elemental_data **ed, struct map_session_data **sd, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_pre[hIndex].func; - retVal___ = preHookFunc(ed, sd, &tick); + retVal___ = preHookFunc(&ed, &sd, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -25999,10 +26096,10 @@ int HP_elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data retVal___ = HPMHooks.source.elemental.ai_sub_timer(ed, sd, tick); } if( HPMHooks.count.HP_elemental_ai_sub_timer_post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct map_session_data *sd, int64 *tick); + int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct map_session_data *sd, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ed, sd, &tick); + retVal___ = postHookFunc(retVal___, ed, sd, tick); } } return retVal___; @@ -26011,12 +26108,12 @@ int HP_elemental_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_elemental_ai_sub_foreachclient_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_foreachclient_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_elemental_ai_sub_foreachclient_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -26059,10 +26156,10 @@ int HP_elemental_ai_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.elemental.ai_timer(tid, tick, id, data); } if( HPMHooks.count.HP_elemental_ai_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_elemental_ai_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -26113,10 +26210,10 @@ void HP_guild_init(bool minimal) { HPMHooks.source.guild.init(minimal); } if( HPMHooks.count.HP_guild_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -26166,10 +26263,10 @@ int HP_guild_skill_get_max(int id) { retVal___ = HPMHooks.source.guild.skill_get_max(id); } if( HPMHooks.count.HP_guild_skill_get_max_post ) { - int (*postHookFunc) (int retVal___, int *id); + int (*postHookFunc) (int retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skill_get_max_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_skill_get_max_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -26178,11 +26275,11 @@ int HP_guild_checkskill(struct guild *g, int id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_checkskill_pre ) { - int (*preHookFunc) (struct guild *g, int *id); + int (*preHookFunc) (struct guild **g, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_checkskill_pre[hIndex].func; - retVal___ = preHookFunc(g, &id); + retVal___ = preHookFunc(&g, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26193,10 +26290,10 @@ int HP_guild_checkskill(struct guild *g, int id) { retVal___ = HPMHooks.source.guild.checkskill(g, id); } if( HPMHooks.count.HP_guild_checkskill_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *id); + int (*postHookFunc) (int retVal___, struct guild *g, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_checkskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &id); + retVal___ = postHookFunc(retVal___, g, id); } } return retVal___; @@ -26205,11 +26302,11 @@ int HP_guild_check_skill_require(struct guild *g, int id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_check_skill_require_pre ) { - int (*preHookFunc) (struct guild *g, int *id); + int (*preHookFunc) (struct guild **g, int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_skill_require_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_check_skill_require_pre[hIndex].func; - retVal___ = preHookFunc(g, &id); + retVal___ = preHookFunc(&g, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26220,10 +26317,10 @@ int HP_guild_check_skill_require(struct guild *g, int id) { retVal___ = HPMHooks.source.guild.check_skill_require(g, id); } if( HPMHooks.count.HP_guild_check_skill_require_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *id); + int (*postHookFunc) (int retVal___, struct guild *g, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_skill_require_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_check_skill_require_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &id); + retVal___ = postHookFunc(retVal___, g, id); } } return retVal___; @@ -26232,11 +26329,11 @@ int HP_guild_checkcastles(struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_checkcastles_pre ) { - int (*preHookFunc) (struct guild *g); + int (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkcastles_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_checkcastles_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26274,10 +26371,10 @@ bool HP_guild_isallied(int guild_id, int guild_id2) { retVal___ = HPMHooks.source.guild.isallied(guild_id, guild_id2); } if( HPMHooks.count.HP_guild_isallied_post ) { - bool (*postHookFunc) (bool retVal___, int *guild_id, int *guild_id2); + bool (*postHookFunc) (bool retVal___, int guild_id, int guild_id2); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_isallied_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_isallied_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &guild_id2); + retVal___ = postHookFunc(retVal___, guild_id, guild_id2); } } return retVal___; @@ -26301,10 +26398,10 @@ struct guild* HP_guild_search(int guild_id) { retVal___ = HPMHooks.source.guild.search(guild_id); } if( HPMHooks.count.HP_guild_search_post ) { - struct guild* (*postHookFunc) (struct guild* retVal___, int *guild_id); + struct guild* (*postHookFunc) (struct guild* retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -26313,11 +26410,11 @@ struct guild* HP_guild_searchname(char *str) { int hIndex = 0; struct guild* retVal___ = NULL; if( HPMHooks.count.HP_guild_searchname_pre ) { - struct guild* (*preHookFunc) (char *str); + struct guild* (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_searchname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_searchname_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26355,10 +26452,10 @@ struct guild_castle* HP_guild_castle_search(int gcid) { retVal___ = HPMHooks.source.guild.castle_search(gcid); } if( HPMHooks.count.HP_guild_castle_search_post ) { - struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int *gcid); + struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int gcid); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_castle_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &gcid); + retVal___ = postHookFunc(retVal___, gcid); } } return retVal___; @@ -26367,11 +26464,11 @@ struct guild_castle* HP_guild_mapname2gc(const char *mapname) { int hIndex = 0; struct guild_castle* retVal___ = NULL; if( HPMHooks.count.HP_guild_mapname2gc_pre ) { - struct guild_castle* (*preHookFunc) (const char *mapname); + struct guild_castle* (*preHookFunc) (const char **mapname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapname2gc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_mapname2gc_pre[hIndex].func; - retVal___ = preHookFunc(mapname); + retVal___ = preHookFunc(&mapname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26409,10 +26506,10 @@ struct guild_castle* HP_guild_mapindex2gc(short map_index) { retVal___ = HPMHooks.source.guild.mapindex2gc(map_index); } if( HPMHooks.count.HP_guild_mapindex2gc_post ) { - struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, short *map_index); + struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, short map_index); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapindex2gc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_mapindex2gc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map_index); + retVal___ = postHookFunc(retVal___, map_index); } } return retVal___; @@ -26421,11 +26518,11 @@ struct map_session_data* HP_guild_getavailablesd(struct guild *g) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_guild_getavailablesd_pre ) { - struct map_session_data* (*preHookFunc) (struct guild *g); + struct map_session_data* (*preHookFunc) (struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getavailablesd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_getavailablesd_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26448,11 +26545,11 @@ int HP_guild_getindex(const struct guild *g, int account_id, int char_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_getindex_pre ) { - int (*preHookFunc) (const struct guild *g, int *account_id, int *char_id); + int (*preHookFunc) (const struct guild **g, int *account_id, int *char_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getindex_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_getindex_pre[hIndex].func; - retVal___ = preHookFunc(g, &account_id, &char_id); + retVal___ = preHookFunc(&g, &account_id, &char_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26463,10 +26560,10 @@ int HP_guild_getindex(const struct guild *g, int account_id, int char_id) { retVal___ = HPMHooks.source.guild.getindex(g, account_id, char_id); } if( HPMHooks.count.HP_guild_getindex_post ) { - int (*postHookFunc) (int retVal___, const struct guild *g, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, const struct guild *g, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getindex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_getindex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, g, account_id, char_id); } } return retVal___; @@ -26475,11 +26572,11 @@ int HP_guild_getposition(struct guild *g, struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_getposition_pre ) { - int (*preHookFunc) (struct guild *g, struct map_session_data *sd); + int (*preHookFunc) (struct guild **g, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getposition_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_getposition_pre[hIndex].func; - retVal___ = preHookFunc(g, sd); + retVal___ = preHookFunc(&g, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26502,11 +26599,11 @@ unsigned int HP_guild_payexp(struct map_session_data *sd, unsigned int exp) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_guild_payexp_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd, unsigned int *exp); + unsigned int (*preHookFunc) (struct map_session_data **sd, unsigned int *exp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_payexp_pre[hIndex].func; - retVal___ = preHookFunc(sd, &exp); + retVal___ = preHookFunc(&sd, &exp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26517,10 +26614,10 @@ unsigned int HP_guild_payexp(struct map_session_data *sd, unsigned int exp) { retVal___ = HPMHooks.source.guild.payexp(sd, exp); } if( HPMHooks.count.HP_guild_payexp_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, unsigned int *exp); + unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, unsigned int exp); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_payexp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &exp); + retVal___ = postHookFunc(retVal___, sd, exp); } } return retVal___; @@ -26529,11 +26626,11 @@ int HP_guild_getexp(struct map_session_data *sd, int exp) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_getexp_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *exp); + int (*preHookFunc) (struct map_session_data **sd, int *exp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_getexp_pre[hIndex].func; - retVal___ = preHookFunc(sd, &exp); + retVal___ = preHookFunc(&sd, &exp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26544,10 +26641,10 @@ int HP_guild_getexp(struct map_session_data *sd, int exp) { retVal___ = HPMHooks.source.guild.getexp(sd, exp); } if( HPMHooks.count.HP_guild_getexp_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *exp); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int exp); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_getexp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &exp); + retVal___ = postHookFunc(retVal___, sd, exp); } } return retVal___; @@ -26556,11 +26653,11 @@ int HP_guild_create(struct map_session_data *sd, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name); + int (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, name); + retVal___ = preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26598,10 +26695,10 @@ int HP_guild_created(int account_id, int guild_id) { retVal___ = HPMHooks.source.guild.created(account_id, guild_id); } if( HPMHooks.count.HP_guild_created_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *guild_id); + int (*postHookFunc) (int retVal___, int account_id, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_created_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &guild_id); + retVal___ = postHookFunc(retVal___, account_id, guild_id); } } return retVal___; @@ -26625,10 +26722,10 @@ int HP_guild_request_info(int guild_id) { retVal___ = HPMHooks.source.guild.request_info(guild_id); } if( HPMHooks.count.HP_guild_request_info_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_request_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_request_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -26652,10 +26749,10 @@ int HP_guild_recv_noinfo(int guild_id) { retVal___ = HPMHooks.source.guild.recv_noinfo(guild_id); } if( HPMHooks.count.HP_guild_recv_noinfo_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_noinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_recv_noinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -26664,11 +26761,11 @@ int HP_guild_recv_info(const struct guild *sg) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_recv_info_pre ) { - int (*preHookFunc) (const struct guild *sg); + int (*preHookFunc) (const struct guild **sg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_recv_info_pre[hIndex].func; - retVal___ = preHookFunc(sg); + retVal___ = preHookFunc(&sg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26691,11 +26788,11 @@ int HP_guild_npc_request_info(int guild_id, const char *ev) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_npc_request_info_pre ) { - int (*preHookFunc) (int *guild_id, const char *ev); + int (*preHookFunc) (int *guild_id, const char **ev); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_npc_request_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_npc_request_info_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, ev); + retVal___ = preHookFunc(&guild_id, &ev); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26706,10 +26803,10 @@ int HP_guild_npc_request_info(int guild_id, const char *ev) { retVal___ = HPMHooks.source.guild.npc_request_info(guild_id, ev); } if( HPMHooks.count.HP_guild_npc_request_info_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, const char *ev); + int (*postHookFunc) (int retVal___, int guild_id, const char *ev); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_npc_request_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_npc_request_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, ev); + retVal___ = postHookFunc(retVal___, guild_id, ev); } } return retVal___; @@ -26718,11 +26815,11 @@ int HP_guild_invite(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_invite_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_invite_pre[hIndex].func; - retVal___ = preHookFunc(sd, tsd); + retVal___ = preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26745,11 +26842,11 @@ int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_reply_invite_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_reply_invite_pre[hIndex].func; - retVal___ = preHookFunc(sd, &guild_id, &flag); + retVal___ = preHookFunc(&sd, &guild_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26760,10 +26857,10 @@ int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) { retVal___ = HPMHooks.source.guild.reply_invite(sd, guild_id, flag); } if( HPMHooks.count.HP_guild_reply_invite_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_invite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_reply_invite_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, sd, guild_id, flag); } } return retVal___; @@ -26771,11 +26868,11 @@ int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) { void HP_guild_member_joined(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_guild_member_joined_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_joined_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_member_joined_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26813,10 +26910,10 @@ int HP_guild_member_added(int guild_id, int account_id, int char_id, int flag) { retVal___ = HPMHooks.source.guild.member_added(guild_id, account_id, char_id, flag); } if( HPMHooks.count.HP_guild_member_added_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_added_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_member_added_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag); } } return retVal___; @@ -26825,11 +26922,11 @@ int HP_guild_leave(struct map_session_data *sd, int guild_id, int account_id, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_leave_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes); + int (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *account_id, int *char_id, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_leave_pre[hIndex].func; - retVal___ = preHookFunc(sd, &guild_id, &account_id, &char_id, mes); + retVal___ = preHookFunc(&sd, &guild_id, &account_id, &char_id, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26840,10 +26937,10 @@ int HP_guild_leave(struct map_session_data *sd, int guild_id, int account_id, in retVal___ = HPMHooks.source.guild.leave(sd, guild_id, account_id, char_id, mes); } if( HPMHooks.count.HP_guild_leave_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &guild_id, &account_id, &char_id, mes); + retVal___ = postHookFunc(retVal___, sd, guild_id, account_id, char_id, mes); } } return retVal___; @@ -26852,11 +26949,11 @@ int HP_guild_member_withdraw(int guild_id, int account_id, int char_id, int flag int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_member_withdraw_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char **name, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_withdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_member_withdraw_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, name, mes); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, &name, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26867,10 +26964,10 @@ int HP_guild_member_withdraw(int guild_id, int account_id, int char_id, int flag retVal___ = HPMHooks.source.guild.member_withdraw(guild_id, account_id, char_id, flag, name, mes); } if( HPMHooks.count.HP_guild_member_withdraw_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_member_withdraw_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag, name, mes); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag, name, mes); } } return retVal___; @@ -26879,11 +26976,11 @@ int HP_guild_expulsion(struct map_session_data *sd, int guild_id, int account_id int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_expulsion_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes); + int (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *account_id, int *char_id, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expulsion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_expulsion_pre[hIndex].func; - retVal___ = preHookFunc(sd, &guild_id, &account_id, &char_id, mes); + retVal___ = preHookFunc(&sd, &guild_id, &account_id, &char_id, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26894,10 +26991,10 @@ int HP_guild_expulsion(struct map_session_data *sd, int guild_id, int account_id retVal___ = HPMHooks.source.guild.expulsion(sd, guild_id, account_id, char_id, mes); } if( HPMHooks.count.HP_guild_expulsion_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expulsion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_expulsion_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &guild_id, &account_id, &char_id, mes); + retVal___ = postHookFunc(retVal___, sd, guild_id, account_id, char_id, mes); } } return retVal___; @@ -26906,11 +27003,11 @@ int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_skillup_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_skillup_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26921,10 +27018,10 @@ int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.guild.skillup(sd, skill_id); } if( HPMHooks.count.HP_guild_skillup_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_skillup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -26932,11 +27029,11 @@ int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) { void HP_guild_block_skill(struct map_session_data *sd, int time) { int hIndex = 0; if( HPMHooks.count.HP_guild_block_skill_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *time); + void (*preHookFunc) (struct map_session_data **sd, int *time); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_block_skill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_block_skill_pre[hIndex].func; - preHookFunc(sd, &time); + preHookFunc(&sd, &time); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26947,10 +27044,10 @@ void HP_guild_block_skill(struct map_session_data *sd, int time) { HPMHooks.source.guild.block_skill(sd, time); } if( HPMHooks.count.HP_guild_block_skill_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *time); + void (*postHookFunc) (struct map_session_data *sd, int time); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_block_skill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_block_skill_post[hIndex].func; - postHookFunc(sd, &time); + postHookFunc(sd, time); } } return; @@ -26959,11 +27056,11 @@ int HP_guild_reqalliance(struct map_session_data *sd, struct map_session_data *t int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_reqalliance_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reqalliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_reqalliance_pre[hIndex].func; - retVal___ = preHookFunc(sd, tsd); + retVal___ = preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -26986,11 +27083,11 @@ int HP_guild_reply_reqalliance(struct map_session_data *sd, int account_id, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_reply_reqalliance_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *account_id, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *account_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_reqalliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_reply_reqalliance_pre[hIndex].func; - retVal___ = preHookFunc(sd, &account_id, &flag); + retVal___ = preHookFunc(&sd, &account_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27001,10 +27098,10 @@ int HP_guild_reply_reqalliance(struct map_session_data *sd, int account_id, int retVal___ = HPMHooks.source.guild.reply_reqalliance(sd, account_id, flag); } if( HPMHooks.count.HP_guild_reply_reqalliance_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_reqalliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_reply_reqalliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &account_id, &flag); + retVal___ = postHookFunc(retVal___, sd, account_id, flag); } } return retVal___; @@ -27013,11 +27110,11 @@ int HP_guild_allianceack(int guild_id1, int guild_id2, int account_id1, int acco int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_allianceack_pre ) { - int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2); + int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char **name1, const char **name2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_allianceack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_allianceack_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2); + retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag, &name1, &name2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27028,10 +27125,10 @@ int HP_guild_allianceack(int guild_id1, int guild_id2, int account_id1, int acco retVal___ = HPMHooks.source.guild.allianceack(guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2); } if( HPMHooks.count.HP_guild_allianceack_post ) { - int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2); + int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_allianceack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_allianceack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2); + retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2); } } return retVal___; @@ -27040,11 +27137,11 @@ int HP_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_delalliance_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_delalliance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_delalliance_pre[hIndex].func; - retVal___ = preHookFunc(sd, &guild_id, &flag); + retVal___ = preHookFunc(&sd, &guild_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27055,10 +27152,10 @@ int HP_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) { retVal___ = HPMHooks.source.guild.delalliance(sd, guild_id, flag); } if( HPMHooks.count.HP_guild_delalliance_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_delalliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_delalliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, sd, guild_id, flag); } } return retVal___; @@ -27067,11 +27164,11 @@ int HP_guild_opposition(struct map_session_data *sd, struct map_session_data *ts int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_opposition_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_opposition_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_opposition_pre[hIndex].func; - retVal___ = preHookFunc(sd, tsd); + retVal___ = preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27109,10 +27206,10 @@ int HP_guild_check_alliance(int guild_id1, int guild_id2, int flag) { retVal___ = HPMHooks.source.guild.check_alliance(guild_id1, guild_id2, flag); } if( HPMHooks.count.HP_guild_check_alliance_post ) { - int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *flag); + int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_alliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_check_alliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &flag); + retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, flag); } } return retVal___; @@ -27121,11 +27218,11 @@ int HP_guild_send_memberinfoshort(struct map_session_data *sd, int online) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_send_memberinfoshort_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *online); + int (*preHookFunc) (struct map_session_data **sd, int *online); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_memberinfoshort_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_send_memberinfoshort_pre[hIndex].func; - retVal___ = preHookFunc(sd, &online); + retVal___ = preHookFunc(&sd, &online); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27136,10 +27233,10 @@ int HP_guild_send_memberinfoshort(struct map_session_data *sd, int online) { retVal___ = HPMHooks.source.guild.send_memberinfoshort(sd, online); } if( HPMHooks.count.HP_guild_send_memberinfoshort_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *online); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int online); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_memberinfoshort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_send_memberinfoshort_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &online); + retVal___ = postHookFunc(retVal___, sd, online); } } return retVal___; @@ -27163,10 +27260,10 @@ int HP_guild_recv_memberinfoshort(int guild_id, int account_id, int char_id, int retVal___ = HPMHooks.source.guild.recv_memberinfoshort(guild_id, account_id, char_id, online, lv, class_); } if( HPMHooks.count.HP_guild_recv_memberinfoshort_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_memberinfoshort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_recv_memberinfoshort_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &online, &lv, &class_); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, online, lv, class_); } } return retVal___; @@ -27190,10 +27287,10 @@ int HP_guild_change_memberposition(int guild_id, int account_id, int char_id, sh retVal___ = HPMHooks.source.guild.change_memberposition(guild_id, account_id, char_id, idx); } if( HPMHooks.count.HP_guild_change_memberposition_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, short *idx); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, short idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_memberposition_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_change_memberposition_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &idx); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, idx); } } return retVal___; @@ -27202,11 +27299,11 @@ int HP_guild_memberposition_changed(struct guild *g, int idx, int pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_memberposition_changed_pre ) { - int (*preHookFunc) (struct guild *g, int *idx, int *pos); + int (*preHookFunc) (struct guild **g, int *idx, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_memberposition_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_memberposition_changed_pre[hIndex].func; - retVal___ = preHookFunc(g, &idx, &pos); + retVal___ = preHookFunc(&g, &idx, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27217,10 +27314,10 @@ int HP_guild_memberposition_changed(struct guild *g, int idx, int pos) { retVal___ = HPMHooks.source.guild.memberposition_changed(g, idx, pos); } if( HPMHooks.count.HP_guild_memberposition_changed_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *idx, int *pos); + int (*postHookFunc) (int retVal___, struct guild *g, int idx, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_memberposition_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_memberposition_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &idx, &pos); + retVal___ = postHookFunc(retVal___, g, idx, pos); } } return retVal___; @@ -27229,11 +27326,11 @@ int HP_guild_change_position(int guild_id, int idx, int mode, int exp_mode, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_change_position_pre ) { - int (*preHookFunc) (int *guild_id, int *idx, int *mode, int *exp_mode, const char *name); + int (*preHookFunc) (int *guild_id, int *idx, int *mode, int *exp_mode, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_position_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_change_position_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &idx, &mode, &exp_mode, name); + retVal___ = preHookFunc(&guild_id, &idx, &mode, &exp_mode, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27244,10 +27341,10 @@ int HP_guild_change_position(int guild_id, int idx, int mode, int exp_mode, cons retVal___ = HPMHooks.source.guild.change_position(guild_id, idx, mode, exp_mode, name); } if( HPMHooks.count.HP_guild_change_position_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *idx, int *mode, int *exp_mode, const char *name); + int (*postHookFunc) (int retVal___, int guild_id, int idx, int mode, int exp_mode, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_position_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_change_position_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &idx, &mode, &exp_mode, name); + retVal___ = postHookFunc(retVal___, guild_id, idx, mode, exp_mode, name); } } return retVal___; @@ -27256,11 +27353,11 @@ int HP_guild_position_changed(int guild_id, int idx, const struct guild_position int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_position_changed_pre ) { - int (*preHookFunc) (int *guild_id, int *idx, const struct guild_position *p); + int (*preHookFunc) (int *guild_id, int *idx, const struct guild_position **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_position_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_position_changed_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &idx, p); + retVal___ = preHookFunc(&guild_id, &idx, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27271,10 +27368,10 @@ int HP_guild_position_changed(int guild_id, int idx, const struct guild_position retVal___ = HPMHooks.source.guild.position_changed(guild_id, idx, p); } if( HPMHooks.count.HP_guild_position_changed_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *idx, const struct guild_position *p); + int (*postHookFunc) (int retVal___, int guild_id, int idx, const struct guild_position *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_position_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_position_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &idx, p); + retVal___ = postHookFunc(retVal___, guild_id, idx, p); } } return retVal___; @@ -27283,11 +27380,11 @@ int HP_guild_change_notice(struct map_session_data *sd, int guild_id, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_change_notice_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *guild_id, const char *mes1, const char *mes2); + int (*preHookFunc) (struct map_session_data **sd, int *guild_id, const char **mes1, const char **mes2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_notice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_change_notice_pre[hIndex].func; - retVal___ = preHookFunc(sd, &guild_id, mes1, mes2); + retVal___ = preHookFunc(&sd, &guild_id, &mes1, &mes2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27298,10 +27395,10 @@ int HP_guild_change_notice(struct map_session_data *sd, int guild_id, const char retVal___ = HPMHooks.source.guild.change_notice(sd, guild_id, mes1, mes2); } if( HPMHooks.count.HP_guild_change_notice_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, const char *mes1, const char *mes2); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, const char *mes1, const char *mes2); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_notice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_change_notice_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &guild_id, mes1, mes2); + retVal___ = postHookFunc(retVal___, sd, guild_id, mes1, mes2); } } return retVal___; @@ -27310,11 +27407,11 @@ int HP_guild_notice_changed(int guild_id, const char *mes1, const char *mes2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_notice_changed_pre ) { - int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2); + int (*preHookFunc) (int *guild_id, const char **mes1, const char **mes2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_notice_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_notice_changed_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, mes1, mes2); + retVal___ = preHookFunc(&guild_id, &mes1, &mes2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27325,10 +27422,10 @@ int HP_guild_notice_changed(int guild_id, const char *mes1, const char *mes2) { retVal___ = HPMHooks.source.guild.notice_changed(guild_id, mes1, mes2); } if( HPMHooks.count.HP_guild_notice_changed_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, const char *mes1, const char *mes2); + int (*postHookFunc) (int retVal___, int guild_id, const char *mes1, const char *mes2); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_notice_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_notice_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, mes1, mes2); + retVal___ = postHookFunc(retVal___, guild_id, mes1, mes2); } } return retVal___; @@ -27337,11 +27434,11 @@ int HP_guild_change_emblem(struct map_session_data *sd, int len, const char *dat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_change_emblem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *len, const char *data); + int (*preHookFunc) (struct map_session_data **sd, int *len, const char **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_emblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_change_emblem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &len, data); + retVal___ = preHookFunc(&sd, &len, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27352,10 +27449,10 @@ int HP_guild_change_emblem(struct map_session_data *sd, int len, const char *dat retVal___ = HPMHooks.source.guild.change_emblem(sd, len, data); } if( HPMHooks.count.HP_guild_change_emblem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *len, const char *data); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int len, const char *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_emblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_change_emblem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &len, data); + retVal___ = postHookFunc(retVal___, sd, len, data); } } return retVal___; @@ -27364,11 +27461,11 @@ int HP_guild_emblem_changed(int len, int guild_id, int emblem_id, const char *da int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_emblem_changed_pre ) { - int (*preHookFunc) (int *len, int *guild_id, int *emblem_id, const char *data); + int (*preHookFunc) (int *len, int *guild_id, int *emblem_id, const char **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_emblem_changed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_emblem_changed_pre[hIndex].func; - retVal___ = preHookFunc(&len, &guild_id, &emblem_id, data); + retVal___ = preHookFunc(&len, &guild_id, &emblem_id, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27379,23 +27476,23 @@ int HP_guild_emblem_changed(int len, int guild_id, int emblem_id, const char *da retVal___ = HPMHooks.source.guild.emblem_changed(len, guild_id, emblem_id, data); } if( HPMHooks.count.HP_guild_emblem_changed_post ) { - int (*postHookFunc) (int retVal___, int *len, int *guild_id, int *emblem_id, const char *data); + int (*postHookFunc) (int retVal___, int len, int guild_id, int emblem_id, const char *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_emblem_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_emblem_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &len, &guild_id, &emblem_id, data); + retVal___ = postHookFunc(retVal___, len, guild_id, emblem_id, data); } } return retVal___; } -int HP_guild_send_message(struct map_session_data *sd, const char *mes, int len) { +int HP_guild_send_message(struct map_session_data *sd, const char *mes) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_send_message_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len); + int (*preHookFunc) (struct map_session_data **sd, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_send_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, mes, &len); + retVal___ = preHookFunc(&sd, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27403,13 +27500,13 @@ int HP_guild_send_message(struct map_session_data *sd, const char *mes, int len) } } { - retVal___ = HPMHooks.source.guild.send_message(sd, mes, len); + retVal___ = HPMHooks.source.guild.send_message(sd, mes); } if( HPMHooks.count.HP_guild_send_message_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes, int *len); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_send_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, mes, &len); + retVal___ = postHookFunc(retVal___, sd, mes); } } return retVal___; @@ -27418,11 +27515,11 @@ int HP_guild_recv_message(int guild_id, int account_id, const char *mes, int len int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_recv_message_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *guild_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_recv_message_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, mes, &len); + retVal___ = preHookFunc(&guild_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27433,10 +27530,10 @@ int HP_guild_recv_message(int guild_id, int account_id, const char *mes, int len retVal___ = HPMHooks.source.guild.recv_message(guild_id, account_id, mes, len); } if( HPMHooks.count.HP_guild_recv_message_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_recv_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, guild_id, account_id, mes, len); } } return retVal___; @@ -27445,11 +27542,11 @@ int HP_guild_send_dot_remove(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_send_dot_remove_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_dot_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_send_dot_remove_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27487,10 +27584,10 @@ int HP_guild_skillupack(int guild_id, uint16 skill_id, int account_id) { retVal___ = HPMHooks.source.guild.skillupack(guild_id, skill_id, account_id); } if( HPMHooks.count.HP_guild_skillupack_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, uint16 *skill_id, int *account_id); + int (*postHookFunc) (int retVal___, int guild_id, uint16 skill_id, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillupack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_skillupack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &skill_id, &account_id); + retVal___ = postHookFunc(retVal___, guild_id, skill_id, account_id); } } return retVal___; @@ -27499,11 +27596,11 @@ int HP_guild_dobreak(struct map_session_data *sd, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_dobreak_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name); + int (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_dobreak_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_dobreak_pre[hIndex].func; - retVal___ = preHookFunc(sd, name); + retVal___ = preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27541,10 +27638,10 @@ int HP_guild_broken(int guild_id, int flag) { retVal___ = HPMHooks.source.guild.broken(guild_id, flag); } if( HPMHooks.count.HP_guild_broken_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *flag); + int (*postHookFunc) (int retVal___, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_broken_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, guild_id, flag); } } return retVal___; @@ -27553,11 +27650,11 @@ int HP_guild_gm_change(int guild_id, struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_gm_change_pre ) { - int (*preHookFunc) (int *guild_id, struct map_session_data *sd); + int (*preHookFunc) (int *guild_id, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_gm_change_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, sd); + retVal___ = preHookFunc(&guild_id, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27568,10 +27665,10 @@ int HP_guild_gm_change(int guild_id, struct map_session_data *sd) { retVal___ = HPMHooks.source.guild.gm_change(guild_id, sd); } if( HPMHooks.count.HP_guild_gm_change_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, struct map_session_data *sd); + int (*postHookFunc) (int retVal___, int guild_id, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_gm_change_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, sd); + retVal___ = postHookFunc(retVal___, guild_id, sd); } } return retVal___; @@ -27595,10 +27692,10 @@ int HP_guild_gm_changed(int guild_id, int account_id, int char_id) { retVal___ = HPMHooks.source.guild.gm_changed(guild_id, account_id, char_id); } if( HPMHooks.count.HP_guild_gm_changed_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_changed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_gm_changed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id); } } return retVal___; @@ -27648,10 +27745,10 @@ int HP_guild_castledatasave(int castle_id, int index, int value) { retVal___ = HPMHooks.source.guild.castledatasave(castle_id, index, value); } if( HPMHooks.count.HP_guild_castledatasave_post ) { - int (*postHookFunc) (int retVal___, int *castle_id, int *index, int *value); + int (*postHookFunc) (int retVal___, int castle_id, int index, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledatasave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_castledatasave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &castle_id, &index, &value); + retVal___ = postHookFunc(retVal___, castle_id, index, value); } } return retVal___; @@ -27660,11 +27757,11 @@ int HP_guild_castledataloadack(int len, const struct guild_castle *gc) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_castledataloadack_pre ) { - int (*preHookFunc) (int *len, const struct guild_castle *gc); + int (*preHookFunc) (int *len, const struct guild_castle **gc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_castledataloadack_pre[hIndex].func; - retVal___ = preHookFunc(&len, gc); + retVal___ = preHookFunc(&len, &gc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27675,10 +27772,10 @@ int HP_guild_castledataloadack(int len, const struct guild_castle *gc) { retVal___ = HPMHooks.source.guild.castledataloadack(len, gc); } if( HPMHooks.count.HP_guild_castledataloadack_post ) { - int (*postHookFunc) (int retVal___, int *len, const struct guild_castle *gc); + int (*postHookFunc) (int retVal___, int len, const struct guild_castle *gc); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_castledataloadack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &len, gc); + retVal___ = postHookFunc(retVal___, len, gc); } } return retVal___; @@ -27701,10 +27798,10 @@ void HP_guild_castle_reconnect(int castle_id, int index, int value) { HPMHooks.source.guild.castle_reconnect(castle_id, index, value); } if( HPMHooks.count.HP_guild_castle_reconnect_post ) { - void (*postHookFunc) (int *castle_id, int *index, int *value); + void (*postHookFunc) (int castle_id, int index, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_castle_reconnect_post[hIndex].func; - postHookFunc(&castle_id, &index, &value); + postHookFunc(castle_id, index, value); } } return; @@ -27816,11 +27913,11 @@ void HP_guild_agit2_end(void) { void HP_guild_flag_add(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_guild_flag_add_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_flag_add_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27842,11 +27939,11 @@ void HP_guild_flag_add(struct npc_data *nd) { void HP_guild_flag_remove(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_guild_flag_remove_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_flag_remove_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27894,11 +27991,11 @@ void HP_guild_flags_clear(void) { void HP_guild_aura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_guild_aura_refresh_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_aura_refresh_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_aura_refresh_pre[hIndex].func; - preHookFunc(sd, &skill_id, &skill_lv); + preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -27909,10 +28006,10 @@ void HP_guild_aura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 HPMHooks.source.guild.aura_refresh(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_guild_aura_refresh_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_aura_refresh_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_aura_refresh_post[hIndex].func; - postHookFunc(sd, &skill_id, &skill_lv); + postHookFunc(sd, skill_id, skill_lv); } } return; @@ -27935,10 +28032,10 @@ void HP_guild_retrieveitembound(int char_id, int aid, int guild_id) { HPMHooks.source.guild.retrieveitembound(char_id, aid, guild_id); } if( HPMHooks.count.HP_guild_retrieveitembound_post ) { - void (*postHookFunc) (int *char_id, int *aid, int *guild_id); + void (*postHookFunc) (int char_id, int aid, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_retrieveitembound_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_retrieveitembound_post[hIndex].func; - postHookFunc(&char_id, &aid, &guild_id); + postHookFunc(char_id, aid, guild_id); } } return; @@ -27962,10 +28059,10 @@ int HP_guild_payexp_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.guild.payexp_timer(tid, tick, id, data); } if( HPMHooks.count.HP_guild_payexp_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_payexp_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -27989,10 +28086,10 @@ struct map_session_data* HP_guild_sd_check(int guild_id, int account_id, int cha retVal___ = HPMHooks.source.guild.sd_check(guild_id, account_id, char_id); } if( HPMHooks.count.HP_guild_sd_check_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *guild_id, int *account_id, int *char_id); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int guild_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_sd_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_sd_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id); } } return retVal___; @@ -28001,11 +28098,11 @@ bool HP_guild_read_guildskill_tree_db(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_guild_read_guildskill_tree_db_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_guildskill_tree_db_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_read_guildskill_tree_db_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28016,10 +28113,10 @@ bool HP_guild_read_guildskill_tree_db(char *split[], int columns, int current) { retVal___ = HPMHooks.source.guild.read_guildskill_tree_db(split, columns, current); } if( HPMHooks.count.HP_guild_read_guildskill_tree_db_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_guildskill_tree_db_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_read_guildskill_tree_db_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -28028,11 +28125,11 @@ bool HP_guild_read_castledb(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_guild_read_castledb_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_castledb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_read_castledb_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28043,10 +28140,10 @@ bool HP_guild_read_castledb(char *str[], int columns, int current) { retVal___ = HPMHooks.source.guild.read_castledb(str, columns, current); } if( HPMHooks.count.HP_guild_read_castledb_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_castledb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_read_castledb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -28055,12 +28152,12 @@ int HP_guild_payexp_timer_sub(union DBKey key, struct DBData *data, va_list ap) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_payexp_timer_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_payexp_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28074,11 +28171,11 @@ int HP_guild_payexp_timer_sub(union DBKey key, struct DBData *data, va_list ap) va_end(ap___copy); } if( HPMHooks.count.HP_guild_payexp_timer_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_payexp_timer_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28088,12 +28185,12 @@ int HP_guild_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_send_xy_timer_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_send_xy_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28107,11 +28204,11 @@ int HP_guild_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) va_end(ap___copy); } if( HPMHooks.count.HP_guild_send_xy_timer_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28136,18 +28233,17 @@ int HP_guild_send_xy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.guild.send_xy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_guild_send_xy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; } struct DBData HP_guild_create_expcache(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_guild_create_expcache_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -28168,11 +28264,11 @@ struct DBData HP_guild_create_expcache(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_guild_create_expcache_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_expcache_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_guild_create_expcache_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -28182,12 +28278,12 @@ int HP_guild_eventlist_db_final(union DBKey key, struct DBData *data, va_list ap int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_eventlist_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_eventlist_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_eventlist_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28201,11 +28297,11 @@ int HP_guild_eventlist_db_final(union DBKey key, struct DBData *data, va_list ap va_end(ap___copy); } if( HPMHooks.count.HP_guild_eventlist_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_eventlist_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_eventlist_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28215,12 +28311,12 @@ int HP_guild_expcache_db_final(union DBKey key, struct DBData *data, va_list ap) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_expcache_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expcache_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_expcache_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28234,11 +28330,11 @@ int HP_guild_expcache_db_final(union DBKey key, struct DBData *data, va_list ap) va_end(ap___copy); } if( HPMHooks.count.HP_guild_expcache_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expcache_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_expcache_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28248,12 +28344,12 @@ int HP_guild_castle_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_castle_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_castle_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28267,11 +28363,11 @@ int HP_guild_castle_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_guild_castle_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_castle_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28281,12 +28377,12 @@ int HP_guild_broken_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_broken_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_broken_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28300,11 +28396,11 @@ int HP_guild_broken_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_guild_broken_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_broken_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28314,12 +28410,12 @@ int HP_guild_castle_broken_sub(union DBKey key, struct DBData *data, va_list ap) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_castle_broken_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_broken_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_castle_broken_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28333,11 +28429,11 @@ int HP_guild_castle_broken_sub(union DBKey key, struct DBData *data, va_list ap) va_end(ap___copy); } if( HPMHooks.count.HP_guild_castle_broken_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_broken_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_guild_castle_broken_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -28346,11 +28442,11 @@ int HP_guild_castle_broken_sub(union DBKey key, struct DBData *data, va_list ap) void HP_guild_makemember(struct guild_member *m, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_guild_makemember_pre ) { - void (*preHookFunc) (struct guild_member *m, struct map_session_data *sd); + void (*preHookFunc) (struct guild_member **m, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_makemember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_makemember_pre[hIndex].func; - preHookFunc(m, sd); + preHookFunc(&m, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28373,11 +28469,11 @@ int HP_guild_check_member(const struct guild *g) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_check_member_pre ) { - int (*preHookFunc) (const struct guild *g); + int (*preHookFunc) (const struct guild **g); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_check_member_pre[hIndex].func; - retVal___ = preHookFunc(g); + retVal___ = preHookFunc(&g); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28400,11 +28496,11 @@ int HP_guild_get_alliance_count(struct guild *g, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_guild_get_alliance_count_pre ) { - int (*preHookFunc) (struct guild *g, int *flag); + int (*preHookFunc) (struct guild **g, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_get_alliance_count_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_guild_get_alliance_count_pre[hIndex].func; - retVal___ = preHookFunc(g, &flag); + retVal___ = preHookFunc(&g, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28415,10 +28511,10 @@ int HP_guild_get_alliance_count(struct guild *g, int flag) { retVal___ = HPMHooks.source.guild.get_alliance_count(g, flag); } if( HPMHooks.count.HP_guild_get_alliance_count_post ) { - int (*postHookFunc) (int retVal___, struct guild *g, int *flag); + int (*postHookFunc) (int retVal___, struct guild *g, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_get_alliance_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_guild_get_alliance_count_post[hIndex].func; - retVal___ = postHookFunc(retVal___, g, &flag); + retVal___ = postHookFunc(retVal___, g, flag); } } return retVal___; @@ -28426,12 +28522,12 @@ int HP_guild_get_alliance_count(struct guild *g, int flag) { void HP_guild_castle_reconnect_sub(void *key, void *data, va_list ap) { int hIndex = 0; if( HPMHooks.count.HP_guild_castle_reconnect_sub_pre ) { - void (*preHookFunc) (void *key, void *data, va_list ap); + void (*preHookFunc) (void **key, void **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_guild_castle_reconnect_sub_pre[hIndex].func; - preHookFunc(key, data, ap___copy); + preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -28475,10 +28571,10 @@ struct guild_storage* HP_gstorage_ensure(int guild_id) { retVal___ = HPMHooks.source.gstorage.ensure(guild_id); } if( HPMHooks.count.HP_gstorage_ensure_post ) { - struct guild_storage* (*postHookFunc) (struct guild_storage* retVal___, int *guild_id); + struct guild_storage* (*postHookFunc) (struct guild_storage* retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_ensure_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_ensure_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -28501,10 +28597,10 @@ void HP_gstorage_init(bool minimal) { HPMHooks.source.gstorage.init(minimal); } if( HPMHooks.count.HP_gstorage_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -28554,10 +28650,10 @@ int HP_gstorage_delete(int guild_id) { retVal___ = HPMHooks.source.gstorage.delete(guild_id); } if( HPMHooks.count.HP_gstorage_delete_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -28566,11 +28662,11 @@ int HP_gstorage_open(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_open_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_open_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28593,11 +28689,11 @@ int HP_gstorage_additem(struct map_session_data *sd, struct guild_storage *stor, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_additem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int *amount); + int (*preHookFunc) (struct map_session_data **sd, struct guild_storage **stor, struct item **item_data, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_additem_pre[hIndex].func; - retVal___ = preHookFunc(sd, stor, item_data, &amount); + retVal___ = preHookFunc(&sd, &stor, &item_data, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28608,10 +28704,10 @@ int HP_gstorage_additem(struct map_session_data *sd, struct guild_storage *stor, retVal___ = HPMHooks.source.gstorage.additem(sd, stor, item_data, amount); } if( HPMHooks.count.HP_gstorage_additem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_additem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, stor, item_data, &amount); + retVal___ = postHookFunc(retVal___, sd, stor, item_data, amount); } } return retVal___; @@ -28620,11 +28716,11 @@ int HP_gstorage_delitem(struct map_session_data *sd, struct guild_storage *stor, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_delitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, int *n, int *amount); + int (*preHookFunc) (struct map_session_data **sd, struct guild_storage **stor, int *n, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_delitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, stor, &n, &amount); + retVal___ = preHookFunc(&sd, &stor, &n, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28635,10 +28731,10 @@ int HP_gstorage_delitem(struct map_session_data *sd, struct guild_storage *stor, retVal___ = HPMHooks.source.gstorage.delitem(sd, stor, n, amount); } if( HPMHooks.count.HP_gstorage_delitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, int *n, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, int n, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_delitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, stor, &n, &amount); + retVal___ = postHookFunc(retVal___, sd, stor, n, amount); } } return retVal___; @@ -28647,11 +28743,11 @@ int HP_gstorage_add(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_add_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_add_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28662,10 +28758,10 @@ int HP_gstorage_add(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.gstorage.add(sd, index, amount); } if( HPMHooks.count.HP_gstorage_add_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -28674,11 +28770,11 @@ int HP_gstorage_get(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_get_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_get_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_get_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28689,10 +28785,10 @@ int HP_gstorage_get(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.gstorage.get(sd, index, amount); } if( HPMHooks.count.HP_gstorage_get_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_get_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_get_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -28701,11 +28797,11 @@ int HP_gstorage_addfromcart(struct map_session_data *sd, int index, int amount) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_addfromcart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_addfromcart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_addfromcart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28716,10 +28812,10 @@ int HP_gstorage_addfromcart(struct map_session_data *sd, int index, int amount) retVal___ = HPMHooks.source.gstorage.addfromcart(sd, index, amount); } if( HPMHooks.count.HP_gstorage_addfromcart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_addfromcart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_addfromcart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -28728,11 +28824,11 @@ int HP_gstorage_gettocart(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_gettocart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_gettocart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_gettocart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28743,10 +28839,10 @@ int HP_gstorage_gettocart(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.gstorage.gettocart(sd, index, amount); } if( HPMHooks.count.HP_gstorage_gettocart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_gettocart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_gettocart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -28755,11 +28851,11 @@ int HP_gstorage_close(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_close_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_close_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28782,11 +28878,11 @@ int HP_gstorage_pc_quit(struct map_session_data *sd, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_gstorage_pc_quit_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_pc_quit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_gstorage_pc_quit_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -28797,10 +28893,10 @@ int HP_gstorage_pc_quit(struct map_session_data *sd, int flag) { retVal___ = HPMHooks.source.gstorage.pc_quit(sd, flag); } if( HPMHooks.count.HP_gstorage_pc_quit_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_pc_quit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_pc_quit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -28824,10 +28920,10 @@ int HP_gstorage_save(int account_id, int guild_id, int flag) { retVal___ = HPMHooks.source.gstorage.save(account_id, guild_id, flag); } if( HPMHooks.count.HP_gstorage_save_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *guild_id, int *flag); + int (*postHookFunc) (int retVal___, int account_id, int guild_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_save_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_save_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &guild_id, &flag); + retVal___ = postHookFunc(retVal___, account_id, guild_id, flag); } } return retVal___; @@ -28851,18 +28947,17 @@ int HP_gstorage_saved(int guild_id) { retVal___ = HPMHooks.source.gstorage.saved(guild_id); } if( HPMHooks.count.HP_gstorage_saved_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_saved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_gstorage_saved_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; } struct DBData HP_gstorage_create(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_gstorage_create_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -28883,11 +28978,11 @@ struct DBData HP_gstorage_create(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_gstorage_create_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_create_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_gstorage_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -28912,10 +29007,10 @@ void HP_homun_init(bool minimal) { HPMHooks.source.homun.init(minimal); } if( HPMHooks.count.HP_homun_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -29017,10 +29112,10 @@ struct view_data* HP_homun_get_viewdata(int class_) { retVal___ = HPMHooks.source.homun.get_viewdata(class_); } if( HPMHooks.count.HP_homun_get_viewdata_post ) { - struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_); + struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_get_viewdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -29044,10 +29139,10 @@ enum homun_type HP_homun_class2type(int class_) { retVal___ = HPMHooks.source.homun.class2type(class_); } if( HPMHooks.count.HP_homun_class2type_post ) { - enum homun_type (*postHookFunc) (enum homun_type retVal___, int *class_); + enum homun_type (*postHookFunc) (enum homun_type retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_class2type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_class2type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -29055,11 +29150,11 @@ enum homun_type HP_homun_class2type(int class_) { void HP_homun_damaged(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_damaged_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_damaged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_damaged_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29082,11 +29177,11 @@ int HP_homun_dead(struct homun_data *hd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_dead_pre ) { - int (*preHookFunc) (struct homun_data *hd); + int (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_dead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_dead_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29109,11 +29204,11 @@ int HP_homun_vaporize(struct map_session_data *sd, enum homun_state flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_vaporize_pre ) { - int (*preHookFunc) (struct map_session_data *sd, enum homun_state *flag); + int (*preHookFunc) (struct map_session_data **sd, enum homun_state *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_vaporize_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29124,10 +29219,10 @@ int HP_homun_vaporize(struct map_session_data *sd, enum homun_state flag) { retVal___ = HPMHooks.source.homun.vaporize(sd, flag); } if( HPMHooks.count.HP_homun_vaporize_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum homun_state *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum homun_state flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_vaporize_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -29136,11 +29231,11 @@ int HP_homun_delete(struct homun_data *hd, int emote) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_delete_pre ) { - int (*preHookFunc) (struct homun_data *hd, int *emote); + int (*preHookFunc) (struct homun_data **hd, int *emote); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_delete_pre[hIndex].func; - retVal___ = preHookFunc(hd, &emote); + retVal___ = preHookFunc(&hd, &emote); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29151,10 +29246,10 @@ int HP_homun_delete(struct homun_data *hd, int emote) { retVal___ = HPMHooks.source.homun.delete(hd, emote); } if( HPMHooks.count.HP_homun_delete_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, int *emote); + int (*postHookFunc) (int retVal___, struct homun_data *hd, int emote); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &emote); + retVal___ = postHookFunc(retVal___, hd, emote); } } return retVal___; @@ -29163,11 +29258,11 @@ int HP_homun_checkskill(struct homun_data *hd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_checkskill_pre ) { - int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id); + int (*preHookFunc) (struct homun_data **hd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_checkskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_checkskill_pre[hIndex].func; - retVal___ = preHookFunc(hd, &skill_id); + retVal___ = preHookFunc(&hd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29178,10 +29273,10 @@ int HP_homun_checkskill(struct homun_data *hd, uint16 skill_id) { retVal___ = HPMHooks.source.homun.checkskill(hd, skill_id); } if( HPMHooks.count.HP_homun_checkskill_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_checkskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_checkskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &skill_id); + retVal___ = postHookFunc(retVal___, hd, skill_id); } } return retVal___; @@ -29190,11 +29285,11 @@ int HP_homun_calc_skilltree(struct homun_data *hd, int flag_evolve) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_calc_skilltree_pre ) { - int (*preHookFunc) (struct homun_data *hd, int *flag_evolve); + int (*preHookFunc) (struct homun_data **hd, int *flag_evolve); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_calc_skilltree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_calc_skilltree_pre[hIndex].func; - retVal___ = preHookFunc(hd, &flag_evolve); + retVal___ = preHookFunc(&hd, &flag_evolve); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29205,10 +29300,10 @@ int HP_homun_calc_skilltree(struct homun_data *hd, int flag_evolve) { retVal___ = HPMHooks.source.homun.calc_skilltree(hd, flag_evolve); } if( HPMHooks.count.HP_homun_calc_skilltree_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, int *flag_evolve); + int (*postHookFunc) (int retVal___, struct homun_data *hd, int flag_evolve); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_calc_skilltree_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_calc_skilltree_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &flag_evolve); + retVal___ = postHookFunc(retVal___, hd, flag_evolve); } } return retVal___; @@ -29232,10 +29327,10 @@ int HP_homun_skill_tree_get_max(int id, int b_class) { retVal___ = HPMHooks.source.homun.skill_tree_get_max(id, b_class); } if( HPMHooks.count.HP_homun_skill_tree_get_max_post ) { - int (*postHookFunc) (int retVal___, int *id, int *b_class); + int (*postHookFunc) (int retVal___, int id, int b_class); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_tree_get_max_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_skill_tree_get_max_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id, &b_class); + retVal___ = postHookFunc(retVal___, id, b_class); } } return retVal___; @@ -29243,11 +29338,11 @@ int HP_homun_skill_tree_get_max(int id, int b_class) { void HP_homun_skillup(struct homun_data *hd, uint16 skill_id) { int hIndex = 0; if( HPMHooks.count.HP_homun_skillup_pre ) { - void (*preHookFunc) (struct homun_data *hd, uint16 *skill_id); + void (*preHookFunc) (struct homun_data **hd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_skillup_pre[hIndex].func; - preHookFunc(hd, &skill_id); + preHookFunc(&hd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29258,10 +29353,10 @@ void HP_homun_skillup(struct homun_data *hd, uint16 skill_id) { HPMHooks.source.homun.skillup(hd, skill_id); } if( HPMHooks.count.HP_homun_skillup_post ) { - void (*postHookFunc) (struct homun_data *hd, uint16 *skill_id); + void (*postHookFunc) (struct homun_data *hd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_skillup_post[hIndex].func; - postHookFunc(hd, &skill_id); + postHookFunc(hd, skill_id); } } return; @@ -29270,11 +29365,11 @@ bool HP_homun_levelup(struct homun_data *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_levelup_pre ) { - bool (*preHookFunc) (struct homun_data *hd); + bool (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_levelup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_levelup_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29297,11 +29392,11 @@ int HP_homun_change_class(struct homun_data *hd, short class_) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_change_class_pre ) { - int (*preHookFunc) (struct homun_data *hd, short *class_); + int (*preHookFunc) (struct homun_data **hd, short *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_class_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_change_class_pre[hIndex].func; - retVal___ = preHookFunc(hd, &class_); + retVal___ = preHookFunc(&hd, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29312,10 +29407,10 @@ int HP_homun_change_class(struct homun_data *hd, short class_) { retVal___ = HPMHooks.source.homun.change_class(hd, class_); } if( HPMHooks.count.HP_homun_change_class_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, short *class_); + int (*postHookFunc) (int retVal___, struct homun_data *hd, short class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_class_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_change_class_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &class_); + retVal___ = postHookFunc(retVal___, hd, class_); } } return retVal___; @@ -29324,11 +29419,11 @@ bool HP_homun_evolve(struct homun_data *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_evolve_pre ) { - bool (*preHookFunc) (struct homun_data *hd); + bool (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_evolve_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_evolve_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29351,11 +29446,11 @@ bool HP_homun_mutate(struct homun_data *hd, int homun_id) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_mutate_pre ) { - bool (*preHookFunc) (struct homun_data *hd, int *homun_id); + bool (*preHookFunc) (struct homun_data **hd, int *homun_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_mutate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_mutate_pre[hIndex].func; - retVal___ = preHookFunc(hd, &homun_id); + retVal___ = preHookFunc(&hd, &homun_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29366,10 +29461,10 @@ bool HP_homun_mutate(struct homun_data *hd, int homun_id) { retVal___ = HPMHooks.source.homun.mutate(hd, homun_id); } if( HPMHooks.count.HP_homun_mutate_post ) { - bool (*postHookFunc) (bool retVal___, struct homun_data *hd, int *homun_id); + bool (*postHookFunc) (bool retVal___, struct homun_data *hd, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_mutate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_mutate_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &homun_id); + retVal___ = postHookFunc(retVal___, hd, homun_id); } } return retVal___; @@ -29378,11 +29473,11 @@ int HP_homun_gainexp(struct homun_data *hd, unsigned int exp) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_gainexp_pre ) { - int (*preHookFunc) (struct homun_data *hd, unsigned int *exp); + int (*preHookFunc) (struct homun_data **hd, unsigned int *exp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_gainexp_pre[hIndex].func; - retVal___ = preHookFunc(hd, &exp); + retVal___ = preHookFunc(&hd, &exp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29393,10 +29488,10 @@ int HP_homun_gainexp(struct homun_data *hd, unsigned int exp) { retVal___ = HPMHooks.source.homun.gainexp(hd, exp); } if( HPMHooks.count.HP_homun_gainexp_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, unsigned int *exp); + int (*postHookFunc) (int retVal___, struct homun_data *hd, unsigned int exp); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_gainexp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &exp); + retVal___ = postHookFunc(retVal___, hd, exp); } } return retVal___; @@ -29405,11 +29500,11 @@ unsigned int HP_homun_add_intimacy(struct homun_data *hd, unsigned int value) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_homun_add_intimacy_pre ) { - unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value); + unsigned int (*preHookFunc) (struct homun_data **hd, unsigned int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_add_intimacy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_add_intimacy_pre[hIndex].func; - retVal___ = preHookFunc(hd, &value); + retVal___ = preHookFunc(&hd, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29420,10 +29515,10 @@ unsigned int HP_homun_add_intimacy(struct homun_data *hd, unsigned int value) { retVal___ = HPMHooks.source.homun.add_intimacy(hd, value); } if( HPMHooks.count.HP_homun_add_intimacy_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int *value); + unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_add_intimacy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_add_intimacy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &value); + retVal___ = postHookFunc(retVal___, hd, value); } } return retVal___; @@ -29432,11 +29527,11 @@ unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_homun_consume_intimacy_pre ) { - unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value); + unsigned int (*preHookFunc) (struct homun_data **hd, unsigned int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_consume_intimacy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_consume_intimacy_pre[hIndex].func; - retVal___ = preHookFunc(hd, &value); + retVal___ = preHookFunc(&hd, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29447,10 +29542,10 @@ unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value retVal___ = HPMHooks.source.homun.consume_intimacy(hd, value); } if( HPMHooks.count.HP_homun_consume_intimacy_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int *value); + unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_consume_intimacy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_consume_intimacy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &value); + retVal___ = postHookFunc(retVal___, hd, value); } } return retVal___; @@ -29458,11 +29553,11 @@ unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value void HP_homun_healed(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_healed_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_healed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_healed_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29484,11 +29579,11 @@ void HP_homun_healed(struct homun_data *hd) { void HP_homun_save(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_save_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_save_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29511,11 +29606,11 @@ unsigned char HP_homun_menu(struct map_session_data *sd, unsigned char menu_num) int hIndex = 0; unsigned char retVal___ = 0; if( HPMHooks.count.HP_homun_menu_pre ) { - unsigned char (*preHookFunc) (struct map_session_data *sd, unsigned char *menu_num); + unsigned char (*preHookFunc) (struct map_session_data **sd, unsigned char *menu_num); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_menu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_menu_pre[hIndex].func; - retVal___ = preHookFunc(sd, &menu_num); + retVal___ = preHookFunc(&sd, &menu_num); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29526,10 +29621,10 @@ unsigned char HP_homun_menu(struct map_session_data *sd, unsigned char menu_num) retVal___ = HPMHooks.source.homun.menu(sd, menu_num); } if( HPMHooks.count.HP_homun_menu_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, unsigned char *menu_num); + unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, unsigned char menu_num); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_menu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_menu_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &menu_num); + retVal___ = postHookFunc(retVal___, sd, menu_num); } } return retVal___; @@ -29538,11 +29633,11 @@ bool HP_homun_feed(struct map_session_data *sd, struct homun_data *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_feed_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd); + bool (*preHookFunc) (struct map_session_data **sd, struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_feed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_feed_pre[hIndex].func; - retVal___ = preHookFunc(sd, hd); + retVal___ = preHookFunc(&sd, &hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29580,10 +29675,10 @@ int HP_homun_hunger_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.homun.hunger_timer(tid, tick, id, data); } if( HPMHooks.count.HP_homun_hunger_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_hunger_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -29591,11 +29686,11 @@ int HP_homun_hunger_timer(int tid, int64 tick, int id, intptr_t data) { void HP_homun_hunger_timer_delete(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_hunger_timer_delete_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_hunger_timer_delete_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29618,11 +29713,11 @@ int HP_homun_change_name(struct map_session_data *sd, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_homun_change_name_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name); + int (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_change_name_pre[hIndex].func; - retVal___ = preHookFunc(sd, name); + retVal___ = preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29645,11 +29740,11 @@ bool HP_homun_change_name_ack(struct map_session_data *sd, const char *name, int int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_change_name_ack_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *name, int *flag); + bool (*preHookFunc) (struct map_session_data **sd, const char **name, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_change_name_ack_pre[hIndex].func; - retVal___ = preHookFunc(sd, name, &flag); + retVal___ = preHookFunc(&sd, &name, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29660,10 +29755,10 @@ bool HP_homun_change_name_ack(struct map_session_data *sd, const char *name, int retVal___ = HPMHooks.source.homun.change_name_ack(sd, name, flag); } if( HPMHooks.count.HP_homun_change_name_ack_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *name, int *flag); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *name, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_change_name_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, name, &flag); + retVal___ = postHookFunc(retVal___, sd, name, flag); } } return retVal___; @@ -29687,10 +29782,10 @@ int HP_homun_db_search(int key, int type) { retVal___ = HPMHooks.source.homun.db_search(key, type); } if( HPMHooks.count.HP_homun_db_search_post ) { - int (*postHookFunc) (int retVal___, int *key, int *type); + int (*postHookFunc) (int retVal___, int key, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_db_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_db_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, &type); + retVal___ = postHookFunc(retVal___, key, type); } } return retVal___; @@ -29699,11 +29794,11 @@ bool HP_homun_create(struct map_session_data *sd, const struct s_homunculus *hom int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_create_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const struct s_homunculus *hom); + bool (*preHookFunc) (struct map_session_data **sd, const struct s_homunculus **hom); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, hom); + retVal___ = preHookFunc(&sd, &hom); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29725,11 +29820,11 @@ bool HP_homun_create(struct map_session_data *sd, const struct s_homunculus *hom void HP_homun_init_timers(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_init_timers_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_timers_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_init_timers_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29752,11 +29847,11 @@ bool HP_homun_call(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_call_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_call_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_call_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29779,11 +29874,11 @@ bool HP_homun_recv_data(int account_id, const struct s_homunculus *sh, int flag) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_recv_data_pre ) { - bool (*preHookFunc) (int *account_id, const struct s_homunculus *sh, int *flag); + bool (*preHookFunc) (int *account_id, const struct s_homunculus **sh, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_recv_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_recv_data_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, sh, &flag); + retVal___ = preHookFunc(&account_id, &sh, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29794,10 +29889,10 @@ bool HP_homun_recv_data(int account_id, const struct s_homunculus *sh, int flag) retVal___ = HPMHooks.source.homun.recv_data(account_id, sh, flag); } if( HPMHooks.count.HP_homun_recv_data_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, const struct s_homunculus *sh, int *flag); + bool (*postHookFunc) (bool retVal___, int account_id, const struct s_homunculus *sh, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_recv_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_recv_data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, sh, &flag); + retVal___ = postHookFunc(retVal___, account_id, sh, flag); } } return retVal___; @@ -29806,11 +29901,11 @@ bool HP_homun_creation_request(struct map_session_data *sd, int class_) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_creation_request_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *class_); + bool (*preHookFunc) (struct map_session_data **sd, int *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_creation_request_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_creation_request_pre[hIndex].func; - retVal___ = preHookFunc(sd, &class_); + retVal___ = preHookFunc(&sd, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29821,10 +29916,10 @@ bool HP_homun_creation_request(struct map_session_data *sd, int class_) { retVal___ = HPMHooks.source.homun.creation_request(sd, class_); } if( HPMHooks.count.HP_homun_creation_request_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *class_); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_creation_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_creation_request_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &class_); + retVal___ = postHookFunc(retVal___, sd, class_); } } return retVal___; @@ -29833,11 +29928,11 @@ bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_ressurect_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned char *per, short *x, short *y); + bool (*preHookFunc) (struct map_session_data **sd, unsigned char *per, short *x, short *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_ressurect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_ressurect_pre[hIndex].func; - retVal___ = preHookFunc(sd, &per, &x, &y); + retVal___ = preHookFunc(&sd, &per, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29848,10 +29943,10 @@ bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x, retVal___ = HPMHooks.source.homun.ressurect(sd, per, x, y); } if( HPMHooks.count.HP_homun_ressurect_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char *per, short *x, short *y); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char per, short x, short y); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_ressurect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_ressurect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &per, &x, &y); + retVal___ = postHookFunc(retVal___, sd, per, x, y); } } return retVal___; @@ -29859,11 +29954,11 @@ bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x, void HP_homun_revive(struct homun_data *hd, unsigned int hp, unsigned int sp) { int hIndex = 0; if( HPMHooks.count.HP_homun_revive_pre ) { - void (*preHookFunc) (struct homun_data *hd, unsigned int *hp, unsigned int *sp); + void (*preHookFunc) (struct homun_data **hd, unsigned int *hp, unsigned int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_revive_pre[hIndex].func; - preHookFunc(hd, &hp, &sp); + preHookFunc(&hd, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29874,10 +29969,10 @@ void HP_homun_revive(struct homun_data *hd, unsigned int hp, unsigned int sp) { HPMHooks.source.homun.revive(hd, hp, sp); } if( HPMHooks.count.HP_homun_revive_post ) { - void (*postHookFunc) (struct homun_data *hd, unsigned int *hp, unsigned int *sp); + void (*postHookFunc) (struct homun_data *hd, unsigned int hp, unsigned int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_revive_post[hIndex].func; - postHookFunc(hd, &hp, &sp); + postHookFunc(hd, hp, sp); } } return; @@ -29885,11 +29980,11 @@ void HP_homun_revive(struct homun_data *hd, unsigned int hp, unsigned int sp) { void HP_homun_stat_reset(struct homun_data *hd) { int hIndex = 0; if( HPMHooks.count.HP_homun_stat_reset_pre ) { - void (*preHookFunc) (struct homun_data *hd); + void (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_stat_reset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_stat_reset_pre[hIndex].func; - preHookFunc(hd); + preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29912,11 +30007,11 @@ bool HP_homun_shuffle(struct homun_data *hd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_shuffle_pre ) { - bool (*preHookFunc) (struct homun_data *hd); + bool (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_shuffle_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_shuffle_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29939,11 +30034,11 @@ bool HP_homun_read_db_sub(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_read_db_sub_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_read_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -29954,10 +30049,10 @@ bool HP_homun_read_db_sub(char *str[], int columns, int current) { retVal___ = HPMHooks.source.homun.read_db_sub(str, columns, current); } if( HPMHooks.count.HP_homun_read_db_sub_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_read_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -29992,11 +30087,11 @@ bool HP_homun_read_skill_db_sub(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_homun_read_skill_db_sub_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_skill_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_read_skill_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30007,10 +30102,10 @@ bool HP_homun_read_skill_db_sub(char *split[], int columns, int current) { retVal___ = HPMHooks.source.homun.read_skill_db_sub(split, columns, current); } if( HPMHooks.count.HP_homun_read_skill_db_sub_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_skill_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_read_skill_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -30070,11 +30165,11 @@ void HP_homun_exp_db_read(void) { void HP_homun_addspiritball(struct homun_data *hd, int max) { int hIndex = 0; if( HPMHooks.count.HP_homun_addspiritball_pre ) { - void (*preHookFunc) (struct homun_data *hd, int *max); + void (*preHookFunc) (struct homun_data **hd, int *max); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_addspiritball_pre[hIndex].func; - preHookFunc(hd, &max); + preHookFunc(&hd, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30085,10 +30180,10 @@ void HP_homun_addspiritball(struct homun_data *hd, int max) { HPMHooks.source.homun.addspiritball(hd, max); } if( HPMHooks.count.HP_homun_addspiritball_post ) { - void (*postHookFunc) (struct homun_data *hd, int *max); + void (*postHookFunc) (struct homun_data *hd, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_addspiritball_post[hIndex].func; - postHookFunc(hd, &max); + postHookFunc(hd, max); } } return; @@ -30096,11 +30191,11 @@ void HP_homun_addspiritball(struct homun_data *hd, int max) { void HP_homun_delspiritball(struct homun_data *hd, int count, int type) { int hIndex = 0; if( HPMHooks.count.HP_homun_delspiritball_pre ) { - void (*preHookFunc) (struct homun_data *hd, int *count, int *type); + void (*preHookFunc) (struct homun_data **hd, int *count, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_delspiritball_pre[hIndex].func; - preHookFunc(hd, &count, &type); + preHookFunc(&hd, &count, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30111,10 +30206,10 @@ void HP_homun_delspiritball(struct homun_data *hd, int count, int type) { HPMHooks.source.homun.delspiritball(hd, count, type); } if( HPMHooks.count.HP_homun_delspiritball_post ) { - void (*postHookFunc) (struct homun_data *hd, int *count, int *type); + void (*postHookFunc) (struct homun_data *hd, int count, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_homun_delspiritball_post[hIndex].func; - postHookFunc(hd, &count, &type); + postHookFunc(hd, count, type); } } return; @@ -30123,11 +30218,11 @@ int8 HP_homun_get_intimacy_grade(struct homun_data *hd) { int hIndex = 0; int8 retVal___ = 0; if( HPMHooks.count.HP_homun_get_intimacy_grade_pre ) { - int8 (*preHookFunc) (struct homun_data *hd); + int8 (*preHookFunc) (struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_intimacy_grade_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_homun_get_intimacy_grade_pre[hIndex].func; - retVal___ = preHookFunc(hd); + retVal___ = preHookFunc(&hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30165,10 +30260,10 @@ void HP_instance_init(bool minimal) { HPMHooks.source.instance.init(minimal); } if( HPMHooks.count.HP_instance_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -30229,11 +30324,11 @@ int HP_instance_create(int party_id, const char *name, enum instance_owner_type int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_instance_create_pre ) { - int (*preHookFunc) (int *party_id, const char *name, enum instance_owner_type *type); + int (*preHookFunc) (int *party_id, const char **name, enum instance_owner_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_instance_create_pre[hIndex].func; - retVal___ = preHookFunc(&party_id, name, &type); + retVal___ = preHookFunc(&party_id, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30244,10 +30339,10 @@ int HP_instance_create(int party_id, const char *name, enum instance_owner_type retVal___ = HPMHooks.source.instance.create(party_id, name, type); } if( HPMHooks.count.HP_instance_create_post ) { - int (*postHookFunc) (int retVal___, int *party_id, const char *name, enum instance_owner_type *type); + int (*postHookFunc) (int retVal___, int party_id, const char *name, enum instance_owner_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, name, &type); + retVal___ = postHookFunc(retVal___, party_id, name, type); } } return retVal___; @@ -30256,11 +30351,11 @@ int HP_instance_add_map(const char *name, int instance_id, bool usebasename, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_instance_add_map_pre ) { - int (*preHookFunc) (const char *name, int *instance_id, bool *usebasename, const char *map_name); + int (*preHookFunc) (const char **name, int *instance_id, bool *usebasename, const char **map_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_add_map_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_instance_add_map_pre[hIndex].func; - retVal___ = preHookFunc(name, &instance_id, &usebasename, map_name); + retVal___ = preHookFunc(&name, &instance_id, &usebasename, &map_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30271,10 +30366,10 @@ int HP_instance_add_map(const char *name, int instance_id, bool usebasename, con retVal___ = HPMHooks.source.instance.add_map(name, instance_id, usebasename, map_name); } if( HPMHooks.count.HP_instance_add_map_post ) { - int (*postHookFunc) (int retVal___, const char *name, int *instance_id, bool *usebasename, const char *map_name); + int (*postHookFunc) (int retVal___, const char *name, int instance_id, bool usebasename, const char *map_name); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_add_map_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_add_map_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &instance_id, &usebasename, map_name); + retVal___ = postHookFunc(retVal___, name, instance_id, usebasename, map_name); } } return retVal___; @@ -30297,10 +30392,10 @@ void HP_instance_del_map(int16 m) { HPMHooks.source.instance.del_map(m); } if( HPMHooks.count.HP_instance_del_map_post ) { - void (*postHookFunc) (int16 *m); + void (*postHookFunc) (int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_del_map_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_del_map_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -30324,10 +30419,10 @@ int HP_instance_map2imap(int16 m, int instance_id) { retVal___ = HPMHooks.source.instance.map2imap(m, instance_id); } if( HPMHooks.count.HP_instance_map2imap_post ) { - int (*postHookFunc) (int retVal___, int16 *m, int *instance_id); + int (*postHookFunc) (int retVal___, int16 m, int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map2imap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_map2imap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, &instance_id); + retVal___ = postHookFunc(retVal___, m, instance_id); } } return retVal___; @@ -30351,10 +30446,10 @@ int HP_instance_mapid2imapid(int16 m, int instance_id) { retVal___ = HPMHooks.source.instance.mapid2imapid(m, instance_id); } if( HPMHooks.count.HP_instance_mapid2imapid_post ) { - int (*postHookFunc) (int retVal___, int16 *m, int *instance_id); + int (*postHookFunc) (int retVal___, int16 m, int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapid2imapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_mapid2imapid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, &instance_id); + retVal___ = postHookFunc(retVal___, m, instance_id); } } return retVal___; @@ -30363,11 +30458,11 @@ int HP_instance_mapname2imap(const char *map_name, int instance_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_instance_mapname2imap_pre ) { - int (*preHookFunc) (const char *map_name, int *instance_id); + int (*preHookFunc) (const char **map_name, int *instance_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapname2imap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_instance_mapname2imap_pre[hIndex].func; - retVal___ = preHookFunc(map_name, &instance_id); + retVal___ = preHookFunc(&map_name, &instance_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30378,10 +30473,10 @@ int HP_instance_mapname2imap(const char *map_name, int instance_id) { retVal___ = HPMHooks.source.instance.mapname2imap(map_name, instance_id); } if( HPMHooks.count.HP_instance_mapname2imap_post ) { - int (*postHookFunc) (int retVal___, const char *map_name, int *instance_id); + int (*postHookFunc) (int retVal___, const char *map_name, int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapname2imap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_mapname2imap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, map_name, &instance_id); + retVal___ = postHookFunc(retVal___, map_name, instance_id); } } return retVal___; @@ -30390,12 +30485,12 @@ int HP_instance_map_npcsub(struct block_list *bl, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_instance_map_npcsub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list args); + int (*preHookFunc) (struct block_list **bl, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map_npcsub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_instance_map_npcsub_pre[hIndex].func; - retVal___ = preHookFunc(bl, args___copy); + retVal___ = preHookFunc(&bl, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -30423,12 +30518,12 @@ int HP_instance_init_npc(struct block_list *bl, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_instance_init_npc_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list args); + int (*preHookFunc) (struct block_list **bl, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_npc_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_instance_init_npc_pre[hIndex].func; - retVal___ = preHookFunc(bl, args___copy); + retVal___ = preHookFunc(&bl, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -30470,10 +30565,10 @@ void HP_instance_destroy(int instance_id) { HPMHooks.source.instance.destroy(instance_id); } if( HPMHooks.count.HP_instance_destroy_post ) { - void (*postHookFunc) (int *instance_id); + void (*postHookFunc) (int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_destroy_post[hIndex].func; - postHookFunc(&instance_id); + postHookFunc(instance_id); } } return; @@ -30496,10 +30591,10 @@ void HP_instance_start(int instance_id) { HPMHooks.source.instance.start(instance_id); } if( HPMHooks.count.HP_instance_start_post ) { - void (*postHookFunc) (int *instance_id); + void (*postHookFunc) (int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_start_post[hIndex].func; - postHookFunc(&instance_id); + postHookFunc(instance_id); } } return; @@ -30522,10 +30617,10 @@ void HP_instance_check_idle(int instance_id) { HPMHooks.source.instance.check_idle(instance_id); } if( HPMHooks.count.HP_instance_check_idle_post ) { - void (*postHookFunc) (int *instance_id); + void (*postHookFunc) (int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_idle_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_check_idle_post[hIndex].func; - postHookFunc(&instance_id); + postHookFunc(instance_id); } } return; @@ -30533,11 +30628,11 @@ void HP_instance_check_idle(int instance_id) { void HP_instance_check_kick(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_instance_check_kick_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_kick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_instance_check_kick_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30574,10 +30669,10 @@ void HP_instance_set_timeout(int instance_id, unsigned int progress_timeout, uns HPMHooks.source.instance.set_timeout(instance_id, progress_timeout, idle_timeout); } if( HPMHooks.count.HP_instance_set_timeout_post ) { - void (*postHookFunc) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout); + void (*postHookFunc) (int instance_id, unsigned int progress_timeout, unsigned int idle_timeout); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_set_timeout_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_set_timeout_post[hIndex].func; - postHookFunc(&instance_id, &progress_timeout, &idle_timeout); + postHookFunc(instance_id, progress_timeout, idle_timeout); } } return; @@ -30601,10 +30696,10 @@ bool HP_instance_valid(int instance_id) { retVal___ = HPMHooks.source.instance.valid(instance_id); } if( HPMHooks.count.HP_instance_valid_post ) { - bool (*postHookFunc) (bool retVal___, int *instance_id); + bool (*postHookFunc) (bool retVal___, int instance_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_valid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_valid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &instance_id); + retVal___ = postHookFunc(retVal___, instance_id); } } return retVal___; @@ -30628,10 +30723,10 @@ int HP_instance_destroy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.instance.destroy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_instance_destroy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_instance_destroy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -30656,10 +30751,10 @@ int HP_intif_parse(int fd) { retVal___ = HPMHooks.source.intif.parse(fd); } if( HPMHooks.count.HP_intif_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -30668,11 +30763,11 @@ int HP_intif_create_pet(int account_id, int char_id, short pet_type, short pet_l int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_create_pet_pre ) { - int (*preHookFunc) (int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, char *pet_name); + int (*preHookFunc) (int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, char **pet_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_pet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_create_pet_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, &char_id, &pet_type, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, pet_name); + retVal___ = preHookFunc(&account_id, &char_id, &pet_type, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, &pet_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30683,23 +30778,23 @@ int HP_intif_create_pet(int account_id, int char_id, short pet_type, short pet_l retVal___ = HPMHooks.source.intif.create_pet(account_id, char_id, pet_type, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name); } if( HPMHooks.count.HP_intif_create_pet_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incubate, char *pet_name); + int (*postHookFunc) (int retVal___, int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, char *pet_name); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_create_pet_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id, &pet_type, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incubate, pet_name); + retVal___ = postHookFunc(retVal___, account_id, char_id, pet_type, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name); } } return retVal___; } -int HP_intif_broadcast(const char *mes, size_t len, int type) { +int HP_intif_broadcast(const char *mes, int len, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_broadcast_pre ) { - int (*preHookFunc) (const char *mes, size_t *len, int *type); + int (*preHookFunc) (const char **mes, int *len, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_broadcast_pre[hIndex].func; - retVal___ = preHookFunc(mes, &len, &type); + retVal___ = preHookFunc(&mes, &len, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30710,23 +30805,23 @@ int HP_intif_broadcast(const char *mes, size_t len, int type) { retVal___ = HPMHooks.source.intif.broadcast(mes, len, type); } if( HPMHooks.count.HP_intif_broadcast_post ) { - int (*postHookFunc) (int retVal___, const char *mes, size_t *len, int *type); + int (*postHookFunc) (int retVal___, const char *mes, int len, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_broadcast_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mes, &len, &type); + retVal___ = postHookFunc(retVal___, mes, len, type); } } return retVal___; } -int HP_intif_broadcast2(const char *mes, size_t len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY) { +int HP_intif_broadcast2(const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_broadcast2_pre ) { - int (*preHookFunc) (const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY); + int (*preHookFunc) (const char **mes, int *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_broadcast2_pre[hIndex].func; - retVal___ = preHookFunc(mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY); + retVal___ = preHookFunc(&mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30737,10 +30832,10 @@ int HP_intif_broadcast2(const char *mes, size_t len, unsigned int fontColor, sho retVal___ = HPMHooks.source.intif.broadcast2(mes, len, fontColor, fontType, fontSize, fontAlign, fontY); } if( HPMHooks.count.HP_intif_broadcast2_post ) { - int (*postHookFunc) (int retVal___, const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY); + int (*postHookFunc) (int retVal___, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_broadcast2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY); + retVal___ = postHookFunc(retVal___, mes, len, fontColor, fontType, fontSize, fontAlign, fontY); } } return retVal___; @@ -30749,11 +30844,11 @@ int HP_intif_main_message(struct map_session_data *sd, const char *message) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_main_message_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *message); + int (*preHookFunc) (struct map_session_data **sd, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_main_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_main_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, message); + retVal___ = preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30772,15 +30867,15 @@ int HP_intif_main_message(struct map_session_data *sd, const char *message) { } return retVal___; } -int HP_intif_wis_message(struct map_session_data *sd, const char *nick, const char *mes, size_t mes_len) { +int HP_intif_wis_message(struct map_session_data *sd, const char *nick, const char *mes, int mes_len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_wis_message_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *nick, const char *mes, size_t *mes_len); + int (*preHookFunc) (struct map_session_data **sd, const char **nick, const char **mes, int *mes_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_wis_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, nick, mes, &mes_len); + retVal___ = preHookFunc(&sd, &nick, &mes, &mes_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30791,10 +30886,10 @@ int HP_intif_wis_message(struct map_session_data *sd, const char *nick, const ch retVal___ = HPMHooks.source.intif.wis_message(sd, nick, mes, mes_len); } if( HPMHooks.count.HP_intif_wis_message_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *nick, const char *mes, size_t *mes_len); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *nick, const char *mes, int mes_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_wis_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, nick, mes, &mes_len); + retVal___ = postHookFunc(retVal___, sd, nick, mes, mes_len); } } return retVal___; @@ -30803,11 +30898,11 @@ int HP_intif_wis_message_to_gm(char *Wisp_name, int permission, char *mes) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_wis_message_to_gm_pre ) { - int (*preHookFunc) (char *Wisp_name, int *permission, char *mes); + int (*preHookFunc) (char **Wisp_name, int *permission, char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_to_gm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_wis_message_to_gm_pre[hIndex].func; - retVal___ = preHookFunc(Wisp_name, &permission, mes); + retVal___ = preHookFunc(&Wisp_name, &permission, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30818,10 +30913,10 @@ int HP_intif_wis_message_to_gm(char *Wisp_name, int permission, char *mes) { retVal___ = HPMHooks.source.intif.wis_message_to_gm(Wisp_name, permission, mes); } if( HPMHooks.count.HP_intif_wis_message_to_gm_post ) { - int (*postHookFunc) (int retVal___, char *Wisp_name, int *permission, char *mes); + int (*postHookFunc) (int retVal___, char *Wisp_name, int permission, char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_to_gm_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_wis_message_to_gm_post[hIndex].func; - retVal___ = postHookFunc(retVal___, Wisp_name, &permission, mes); + retVal___ = postHookFunc(retVal___, Wisp_name, permission, mes); } } return retVal___; @@ -30830,11 +30925,11 @@ int HP_intif_saveregistry(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_saveregistry_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_saveregistry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_saveregistry_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30857,11 +30952,11 @@ int HP_intif_request_registry(struct map_session_data *sd, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_request_registry_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_registry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_request_registry_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30872,10 +30967,10 @@ int HP_intif_request_registry(struct map_session_data *sd, int flag) { retVal___ = HPMHooks.source.intif.request_registry(sd, flag); } if( HPMHooks.count.HP_intif_request_registry_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_registry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_request_registry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -30899,10 +30994,10 @@ int HP_intif_request_guild_storage(int account_id, int guild_id) { retVal___ = HPMHooks.source.intif.request_guild_storage(account_id, guild_id); } if( HPMHooks.count.HP_intif_request_guild_storage_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *guild_id); + int (*postHookFunc) (int retVal___, int account_id, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_guild_storage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_request_guild_storage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &guild_id); + retVal___ = postHookFunc(retVal___, account_id, guild_id); } } return retVal___; @@ -30911,11 +31006,11 @@ int HP_intif_send_guild_storage(int account_id, struct guild_storage *gstor) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_send_guild_storage_pre ) { - int (*preHookFunc) (int *account_id, struct guild_storage *gstor); + int (*preHookFunc) (int *account_id, struct guild_storage **gstor); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_send_guild_storage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_send_guild_storage_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, gstor); + retVal___ = preHookFunc(&account_id, &gstor); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30926,10 +31021,10 @@ int HP_intif_send_guild_storage(int account_id, struct guild_storage *gstor) { retVal___ = HPMHooks.source.intif.send_guild_storage(account_id, gstor); } if( HPMHooks.count.HP_intif_send_guild_storage_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct guild_storage *gstor); + int (*postHookFunc) (int retVal___, int account_id, struct guild_storage *gstor); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_send_guild_storage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_send_guild_storage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, gstor); + retVal___ = postHookFunc(retVal___, account_id, gstor); } } return retVal___; @@ -30938,11 +31033,11 @@ int HP_intif_create_party(struct party_member *member, const char *name, int ite int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_create_party_pre ) { - int (*preHookFunc) (struct party_member *member, const char *name, int *item, int *item2); + int (*preHookFunc) (struct party_member **member, const char **name, int *item, int *item2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_party_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_create_party_pre[hIndex].func; - retVal___ = preHookFunc(member, name, &item, &item2); + retVal___ = preHookFunc(&member, &name, &item, &item2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -30953,10 +31048,10 @@ int HP_intif_create_party(struct party_member *member, const char *name, int ite retVal___ = HPMHooks.source.intif.create_party(member, name, item, item2); } if( HPMHooks.count.HP_intif_create_party_post ) { - int (*postHookFunc) (int retVal___, struct party_member *member, const char *name, int *item, int *item2); + int (*postHookFunc) (int retVal___, struct party_member *member, const char *name, int item, int item2); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_party_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_create_party_post[hIndex].func; - retVal___ = postHookFunc(retVal___, member, name, &item, &item2); + retVal___ = postHookFunc(retVal___, member, name, item, item2); } } return retVal___; @@ -30980,10 +31075,10 @@ int HP_intif_request_partyinfo(int party_id, int char_id) { retVal___ = HPMHooks.source.intif.request_partyinfo(party_id, char_id); } if( HPMHooks.count.HP_intif_request_partyinfo_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_partyinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_request_partyinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, char_id); } } return retVal___; @@ -30992,11 +31087,11 @@ int HP_intif_party_addmember(int party_id, struct party_member *member) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_party_addmember_pre ) { - int (*preHookFunc) (int *party_id, struct party_member *member); + int (*preHookFunc) (int *party_id, struct party_member **member); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_addmember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_party_addmember_pre[hIndex].func; - retVal___ = preHookFunc(&party_id, member); + retVal___ = preHookFunc(&party_id, &member); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31007,10 +31102,10 @@ int HP_intif_party_addmember(int party_id, struct party_member *member) { retVal___ = HPMHooks.source.intif.party_addmember(party_id, member); } if( HPMHooks.count.HP_intif_party_addmember_post ) { - int (*postHookFunc) (int retVal___, int *party_id, struct party_member *member); + int (*postHookFunc) (int retVal___, int party_id, struct party_member *member); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_addmember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_addmember_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, member); + retVal___ = postHookFunc(retVal___, party_id, member); } } return retVal___; @@ -31034,10 +31129,10 @@ int HP_intif_party_changeoption(int party_id, int account_id, int exp, int item) retVal___ = HPMHooks.source.intif.party_changeoption(party_id, account_id, exp, item); } if( HPMHooks.count.HP_intif_party_changeoption_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *exp, int *item); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int exp, int item); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changeoption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_changeoption_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &exp, &item); + retVal___ = postHookFunc(retVal___, party_id, account_id, exp, item); } } return retVal___; @@ -31061,10 +31156,10 @@ int HP_intif_party_leave(int party_id, int account_id, int char_id) { retVal___ = HPMHooks.source.intif.party_leave(party_id, account_id, char_id); } if( HPMHooks.count.HP_intif_party_leave_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -31073,11 +31168,11 @@ int HP_intif_party_changemap(struct map_session_data *sd, int online) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_party_changemap_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *online); + int (*preHookFunc) (struct map_session_data **sd, int *online); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changemap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_party_changemap_pre[hIndex].func; - retVal___ = preHookFunc(sd, &online); + retVal___ = preHookFunc(&sd, &online); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31088,10 +31183,10 @@ int HP_intif_party_changemap(struct map_session_data *sd, int online) { retVal___ = HPMHooks.source.intif.party_changemap(sd, online); } if( HPMHooks.count.HP_intif_party_changemap_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *online); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int online); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_changemap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &online); + retVal___ = postHookFunc(retVal___, sd, online); } } return retVal___; @@ -31115,10 +31210,10 @@ int HP_intif_break_party(int party_id) { retVal___ = HPMHooks.source.intif.break_party(party_id); } if( HPMHooks.count.HP_intif_break_party_post ) { - int (*postHookFunc) (int retVal___, int *party_id); + int (*postHookFunc) (int retVal___, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_break_party_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_break_party_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id); + retVal___ = postHookFunc(retVal___, party_id); } } return retVal___; @@ -31127,11 +31222,11 @@ int HP_intif_party_message(int party_id, int account_id, const char *mes, int le int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_party_message_pre ) { - int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *party_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_party_message_pre[hIndex].func; - retVal___ = preHookFunc(&party_id, &account_id, mes, &len); + retVal___ = preHookFunc(&party_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31142,10 +31237,10 @@ int HP_intif_party_message(int party_id, int account_id, const char *mes, int le retVal___ = HPMHooks.source.intif.party_message(party_id, account_id, mes, len); } if( HPMHooks.count.HP_intif_party_message_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int party_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, party_id, account_id, mes, len); } } return retVal___; @@ -31169,10 +31264,10 @@ int HP_intif_party_leaderchange(int party_id, int account_id, int char_id) { retVal___ = HPMHooks.source.intif.party_leaderchange(party_id, account_id, char_id); } if( HPMHooks.count.HP_intif_party_leaderchange_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leaderchange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_party_leaderchange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -31181,11 +31276,11 @@ int HP_intif_guild_create(const char *name, const struct guild_member *master) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_create_pre ) { - int (*preHookFunc) (const char *name, const struct guild_member *master); + int (*preHookFunc) (const char **name, const struct guild_member **master); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_create_pre[hIndex].func; - retVal___ = preHookFunc(name, master); + retVal___ = preHookFunc(&name, &master); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31223,10 +31318,10 @@ int HP_intif_guild_request_info(int guild_id) { retVal___ = HPMHooks.source.intif.guild_request_info(guild_id); } if( HPMHooks.count.HP_intif_guild_request_info_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_request_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_request_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -31235,11 +31330,11 @@ int HP_intif_guild_addmember(int guild_id, struct guild_member *m) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_addmember_pre ) { - int (*preHookFunc) (int *guild_id, struct guild_member *m); + int (*preHookFunc) (int *guild_id, struct guild_member **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_addmember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_addmember_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, m); + retVal___ = preHookFunc(&guild_id, &m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31250,10 +31345,10 @@ int HP_intif_guild_addmember(int guild_id, struct guild_member *m) { retVal___ = HPMHooks.source.intif.guild_addmember(guild_id, m); } if( HPMHooks.count.HP_intif_guild_addmember_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, struct guild_member *m); + int (*postHookFunc) (int retVal___, int guild_id, struct guild_member *m); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_addmember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_addmember_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, m); + retVal___ = postHookFunc(retVal___, guild_id, m); } } return retVal___; @@ -31262,11 +31357,11 @@ int HP_intif_guild_leave(int guild_id, int account_id, int char_id, int flag, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_leave_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *mes); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_leave_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, mes); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31277,10 +31372,10 @@ int HP_intif_guild_leave(int guild_id, int account_id, int char_id, int flag, co retVal___ = HPMHooks.source.intif.guild_leave(guild_id, account_id, char_id, flag, mes); } if( HPMHooks.count.HP_intif_guild_leave_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag, const char *mes); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_leave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_leave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag, mes); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag, mes); } } return retVal___; @@ -31304,10 +31399,10 @@ int HP_intif_guild_memberinfoshort(int guild_id, int account_id, int char_id, in retVal___ = HPMHooks.source.intif.guild_memberinfoshort(guild_id, account_id, char_id, online, lv, class_); } if( HPMHooks.count.HP_intif_guild_memberinfoshort_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_memberinfoshort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_memberinfoshort_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &online, &lv, &class_); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, online, lv, class_); } } return retVal___; @@ -31331,10 +31426,10 @@ int HP_intif_guild_break(int guild_id) { retVal___ = HPMHooks.source.intif.guild_break(guild_id); } if( HPMHooks.count.HP_intif_guild_break_post ) { - int (*postHookFunc) (int retVal___, int *guild_id); + int (*postHookFunc) (int retVal___, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_break_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_break_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id); + retVal___ = postHookFunc(retVal___, guild_id); } } return retVal___; @@ -31343,11 +31438,11 @@ int HP_intif_guild_message(int guild_id, int account_id, const char *mes, int le int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_message_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *guild_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_message_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, mes, &len); + retVal___ = preHookFunc(&guild_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31358,23 +31453,23 @@ int HP_intif_guild_message(int guild_id, int account_id, const char *mes, int le retVal___ = HPMHooks.source.intif.guild_message(guild_id, account_id, mes, len); } if( HPMHooks.count.HP_intif_guild_message_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, guild_id, account_id, mes, len); } } return retVal___; } -int HP_intif_guild_change_gm(int guild_id, const char *name, size_t len) { +int HP_intif_guild_change_gm(int guild_id, const char *name, int len) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_change_gm_pre ) { - int (*preHookFunc) (int *guild_id, const char *name, size_t *len); + int (*preHookFunc) (int *guild_id, const char **name, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_gm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_change_gm_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, name, &len); + retVal___ = preHookFunc(&guild_id, &name, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31385,10 +31480,10 @@ int HP_intif_guild_change_gm(int guild_id, const char *name, size_t len) { retVal___ = HPMHooks.source.intif.guild_change_gm(guild_id, name, len); } if( HPMHooks.count.HP_intif_guild_change_gm_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, const char *name, size_t *len); + int (*postHookFunc) (int retVal___, int guild_id, const char *name, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_gm_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_change_gm_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, name, &len); + retVal___ = postHookFunc(retVal___, guild_id, name, len); } } return retVal___; @@ -31397,11 +31492,11 @@ int HP_intif_guild_change_basicinfo(int guild_id, int type, const void *data, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_change_basicinfo_pre ) { - int (*preHookFunc) (int *guild_id, int *type, const void *data, int *len); + int (*preHookFunc) (int *guild_id, int *type, const void **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_basicinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_change_basicinfo_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &type, data, &len); + retVal___ = preHookFunc(&guild_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31412,10 +31507,10 @@ int HP_intif_guild_change_basicinfo(int guild_id, int type, const void *data, in retVal___ = HPMHooks.source.intif.guild_change_basicinfo(guild_id, type, data, len); } if( HPMHooks.count.HP_intif_guild_change_basicinfo_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *type, const void *data, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int type, const void *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_basicinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_change_basicinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, guild_id, type, data, len); } } return retVal___; @@ -31424,11 +31519,11 @@ int HP_intif_guild_change_memberinfo(int guild_id, int account_id, int char_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_change_memberinfo_pre ) { - int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len); + int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *type, const void **data, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_memberinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_change_memberinfo_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &type, &data, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31439,10 +31534,10 @@ int HP_intif_guild_change_memberinfo(int guild_id, int account_id, int char_id, retVal___ = HPMHooks.source.intif.guild_change_memberinfo(guild_id, account_id, char_id, type, data, len); } if( HPMHooks.count.HP_intif_guild_change_memberinfo_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len); + int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int type, const void *data, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_memberinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_change_memberinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &type, data, &len); + retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, type, data, len); } } return retVal___; @@ -31451,11 +31546,11 @@ int HP_intif_guild_position(int guild_id, int idx, struct guild_position *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_position_pre ) { - int (*preHookFunc) (int *guild_id, int *idx, struct guild_position *p); + int (*preHookFunc) (int *guild_id, int *idx, struct guild_position **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_position_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_position_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &idx, p); + retVal___ = preHookFunc(&guild_id, &idx, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31466,10 +31561,10 @@ int HP_intif_guild_position(int guild_id, int idx, struct guild_position *p) { retVal___ = HPMHooks.source.intif.guild_position(guild_id, idx, p); } if( HPMHooks.count.HP_intif_guild_position_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *idx, struct guild_position *p); + int (*postHookFunc) (int retVal___, int guild_id, int idx, struct guild_position *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_position_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_position_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &idx, p); + retVal___ = postHookFunc(retVal___, guild_id, idx, p); } } return retVal___; @@ -31493,10 +31588,10 @@ int HP_intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int ma retVal___ = HPMHooks.source.intif.guild_skillup(guild_id, skill_id, account_id, max); } if( HPMHooks.count.HP_intif_guild_skillup_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, uint16 *skill_id, int *account_id, int *max); + int (*postHookFunc) (int retVal___, int guild_id, uint16 skill_id, int account_id, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_skillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_skillup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &skill_id, &account_id, &max); + retVal___ = postHookFunc(retVal___, guild_id, skill_id, account_id, max); } } return retVal___; @@ -31520,10 +31615,10 @@ int HP_intif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int a retVal___ = HPMHooks.source.intif.guild_alliance(guild_id1, guild_id2, account_id1, account_id2, flag); } if( HPMHooks.count.HP_intif_guild_alliance_post ) { - int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag); + int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_alliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_alliance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag); + retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, account_id1, account_id2, flag); } } return retVal___; @@ -31532,11 +31627,11 @@ int HP_intif_guild_notice(int guild_id, const char *mes1, const char *mes2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_notice_pre ) { - int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2); + int (*preHookFunc) (int *guild_id, const char **mes1, const char **mes2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_notice_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_notice_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, mes1, mes2); + retVal___ = preHookFunc(&guild_id, &mes1, &mes2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31547,10 +31642,10 @@ int HP_intif_guild_notice(int guild_id, const char *mes1, const char *mes2) { retVal___ = HPMHooks.source.intif.guild_notice(guild_id, mes1, mes2); } if( HPMHooks.count.HP_intif_guild_notice_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, const char *mes1, const char *mes2); + int (*postHookFunc) (int retVal___, int guild_id, const char *mes1, const char *mes2); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_notice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_notice_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, mes1, mes2); + retVal___ = postHookFunc(retVal___, guild_id, mes1, mes2); } } return retVal___; @@ -31559,11 +31654,11 @@ int HP_intif_guild_emblem(int guild_id, int len, const char *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_emblem_pre ) { - int (*preHookFunc) (int *guild_id, int *len, const char *data); + int (*preHookFunc) (int *guild_id, int *len, const char **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_emblem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_emblem_pre[hIndex].func; - retVal___ = preHookFunc(&guild_id, &len, data); + retVal___ = preHookFunc(&guild_id, &len, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31574,10 +31669,10 @@ int HP_intif_guild_emblem(int guild_id, int len, const char *data) { retVal___ = HPMHooks.source.intif.guild_emblem(guild_id, len, data); } if( HPMHooks.count.HP_intif_guild_emblem_post ) { - int (*postHookFunc) (int retVal___, int *guild_id, int *len, const char *data); + int (*postHookFunc) (int retVal___, int guild_id, int len, const char *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_emblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_emblem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &guild_id, &len, data); + retVal___ = postHookFunc(retVal___, guild_id, len, data); } } return retVal___; @@ -31586,11 +31681,11 @@ int HP_intif_guild_castle_dataload(int num, int *castle_ids) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_guild_castle_dataload_pre ) { - int (*preHookFunc) (int *num, int *castle_ids); + int (*preHookFunc) (int *num, int **castle_ids); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_dataload_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_guild_castle_dataload_pre[hIndex].func; - retVal___ = preHookFunc(&num, castle_ids); + retVal___ = preHookFunc(&num, &castle_ids); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31601,10 +31696,10 @@ int HP_intif_guild_castle_dataload(int num, int *castle_ids) { retVal___ = HPMHooks.source.intif.guild_castle_dataload(num, castle_ids); } if( HPMHooks.count.HP_intif_guild_castle_dataload_post ) { - int (*postHookFunc) (int retVal___, int *num, int *castle_ids); + int (*postHookFunc) (int retVal___, int num, int *castle_ids); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_dataload_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_castle_dataload_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &num, castle_ids); + retVal___ = postHookFunc(retVal___, num, castle_ids); } } return retVal___; @@ -31628,10 +31723,10 @@ int HP_intif_guild_castle_datasave(int castle_id, int index, int value) { retVal___ = HPMHooks.source.intif.guild_castle_datasave(castle_id, index, value); } if( HPMHooks.count.HP_intif_guild_castle_datasave_post ) { - int (*postHookFunc) (int retVal___, int *castle_id, int *index, int *value); + int (*postHookFunc) (int retVal___, int castle_id, int index, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_datasave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_guild_castle_datasave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &castle_id, &index, &value); + retVal___ = postHookFunc(retVal___, castle_id, index, value); } } return retVal___; @@ -31654,10 +31749,10 @@ void HP_intif_itembound_req(int char_id, int aid, int guild_id) { HPMHooks.source.intif.itembound_req(char_id, aid, guild_id); } if( HPMHooks.count.HP_intif_itembound_req_post ) { - void (*postHookFunc) (int *char_id, int *aid, int *guild_id); + void (*postHookFunc) (int char_id, int aid, int guild_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_itembound_req_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_itembound_req_post[hIndex].func; - postHookFunc(&char_id, &aid, &guild_id); + postHookFunc(char_id, aid, guild_id); } } return; @@ -31681,10 +31776,10 @@ int HP_intif_request_petdata(int account_id, int char_id, int pet_id) { retVal___ = HPMHooks.source.intif.request_petdata(account_id, char_id, pet_id); } if( HPMHooks.count.HP_intif_request_petdata_post ) { - int (*postHookFunc) (int retVal___, int *account_id, int *char_id, int *pet_id); + int (*postHookFunc) (int retVal___, int account_id, int char_id, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_petdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_request_petdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &char_id, &pet_id); + retVal___ = postHookFunc(retVal___, account_id, char_id, pet_id); } } return retVal___; @@ -31693,11 +31788,11 @@ int HP_intif_save_petdata(int account_id, struct s_pet *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_save_petdata_pre ) { - int (*preHookFunc) (int *account_id, struct s_pet *p); + int (*preHookFunc) (int *account_id, struct s_pet **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_save_petdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_save_petdata_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, p); + retVal___ = preHookFunc(&account_id, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31708,10 +31803,10 @@ int HP_intif_save_petdata(int account_id, struct s_pet *p) { retVal___ = HPMHooks.source.intif.save_petdata(account_id, p); } if( HPMHooks.count.HP_intif_save_petdata_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct s_pet *p); + int (*postHookFunc) (int retVal___, int account_id, struct s_pet *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_save_petdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_save_petdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, p); + retVal___ = postHookFunc(retVal___, account_id, p); } } return retVal___; @@ -31735,10 +31830,10 @@ int HP_intif_delete_petdata(int pet_id) { retVal___ = HPMHooks.source.intif.delete_petdata(pet_id); } if( HPMHooks.count.HP_intif_delete_petdata_post ) { - int (*postHookFunc) (int retVal___, int *pet_id); + int (*postHookFunc) (int retVal___, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_delete_petdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_delete_petdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &pet_id); + retVal___ = postHookFunc(retVal___, pet_id); } } return retVal___; @@ -31747,11 +31842,11 @@ int HP_intif_rename(struct map_session_data *sd, int type, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_rename_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, const char *name); + int (*preHookFunc) (struct map_session_data **sd, int *type, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_rename_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_rename_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, name); + retVal___ = preHookFunc(&sd, &type, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31762,10 +31857,10 @@ int HP_intif_rename(struct map_session_data *sd, int type, const char *name) { retVal___ = HPMHooks.source.intif.rename(sd, type, name); } if( HPMHooks.count.HP_intif_rename_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, const char *name); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_rename_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_rename_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, name); + retVal___ = postHookFunc(retVal___, sd, type, name); } } return retVal___; @@ -31774,11 +31869,11 @@ int HP_intif_homunculus_create(int account_id, struct s_homunculus *sh) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_homunculus_create_pre ) { - int (*preHookFunc) (int *account_id, struct s_homunculus *sh); + int (*preHookFunc) (int *account_id, struct s_homunculus **sh); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_homunculus_create_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, sh); + retVal___ = preHookFunc(&account_id, &sh); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31789,10 +31884,10 @@ int HP_intif_homunculus_create(int account_id, struct s_homunculus *sh) { retVal___ = HPMHooks.source.intif.homunculus_create(account_id, sh); } if( HPMHooks.count.HP_intif_homunculus_create_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct s_homunculus *sh); + int (*postHookFunc) (int retVal___, int account_id, struct s_homunculus *sh); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_homunculus_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, sh); + retVal___ = postHookFunc(retVal___, account_id, sh); } } return retVal___; @@ -31816,10 +31911,10 @@ bool HP_intif_homunculus_requestload(int account_id, int homun_id) { retVal___ = HPMHooks.source.intif.homunculus_requestload(account_id, homun_id); } if( HPMHooks.count.HP_intif_homunculus_requestload_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, int *homun_id); + bool (*postHookFunc) (bool retVal___, int account_id, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestload_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_homunculus_requestload_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &homun_id); + retVal___ = postHookFunc(retVal___, account_id, homun_id); } } return retVal___; @@ -31828,11 +31923,11 @@ int HP_intif_homunculus_requestsave(int account_id, struct s_homunculus *sh) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_homunculus_requestsave_pre ) { - int (*preHookFunc) (int *account_id, struct s_homunculus *sh); + int (*preHookFunc) (int *account_id, struct s_homunculus **sh); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestsave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_homunculus_requestsave_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, sh); + retVal___ = preHookFunc(&account_id, &sh); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31843,10 +31938,10 @@ int HP_intif_homunculus_requestsave(int account_id, struct s_homunculus *sh) { retVal___ = HPMHooks.source.intif.homunculus_requestsave(account_id, sh); } if( HPMHooks.count.HP_intif_homunculus_requestsave_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct s_homunculus *sh); + int (*postHookFunc) (int retVal___, int account_id, struct s_homunculus *sh); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestsave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_homunculus_requestsave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, sh); + retVal___ = postHookFunc(retVal___, account_id, sh); } } return retVal___; @@ -31870,10 +31965,10 @@ int HP_intif_homunculus_requestdelete(int homun_id) { retVal___ = HPMHooks.source.intif.homunculus_requestdelete(homun_id); } if( HPMHooks.count.HP_intif_homunculus_requestdelete_post ) { - int (*postHookFunc) (int retVal___, int *homun_id); + int (*postHookFunc) (int retVal___, int homun_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestdelete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_homunculus_requestdelete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &homun_id); + retVal___ = postHookFunc(retVal___, homun_id); } } return retVal___; @@ -31881,11 +31976,11 @@ int HP_intif_homunculus_requestdelete(int homun_id) { void HP_intif_request_questlog(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_intif_request_questlog_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_questlog_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_request_questlog_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31908,11 +32003,11 @@ int HP_intif_quest_save(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_quest_save_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_quest_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_quest_save_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31935,11 +32030,11 @@ int HP_intif_mercenary_create(struct s_mercenary *merc) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_mercenary_create_pre ) { - int (*preHookFunc) (struct s_mercenary *merc); + int (*preHookFunc) (struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_mercenary_create_pre[hIndex].func; - retVal___ = preHookFunc(merc); + retVal___ = preHookFunc(&merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -31977,10 +32072,10 @@ int HP_intif_mercenary_request(int merc_id, int char_id) { retVal___ = HPMHooks.source.intif.mercenary_request(merc_id, char_id); } if( HPMHooks.count.HP_intif_mercenary_request_post ) { - int (*postHookFunc) (int retVal___, int *merc_id, int *char_id); + int (*postHookFunc) (int retVal___, int merc_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_mercenary_request_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &merc_id, &char_id); + retVal___ = postHookFunc(retVal___, merc_id, char_id); } } return retVal___; @@ -32004,10 +32099,10 @@ int HP_intif_mercenary_delete(int merc_id) { retVal___ = HPMHooks.source.intif.mercenary_delete(merc_id); } if( HPMHooks.count.HP_intif_mercenary_delete_post ) { - int (*postHookFunc) (int retVal___, int *merc_id); + int (*postHookFunc) (int retVal___, int merc_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_mercenary_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &merc_id); + retVal___ = postHookFunc(retVal___, merc_id); } } return retVal___; @@ -32016,11 +32111,11 @@ int HP_intif_mercenary_save(struct s_mercenary *merc) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_mercenary_save_pre ) { - int (*preHookFunc) (struct s_mercenary *merc); + int (*preHookFunc) (struct s_mercenary **merc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_mercenary_save_pre[hIndex].func; - retVal___ = preHookFunc(merc); + retVal___ = preHookFunc(&merc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32058,10 +32153,10 @@ int HP_intif_Mail_requestinbox(int char_id, unsigned char flag) { retVal___ = HPMHooks.source.intif.Mail_requestinbox(char_id, flag); } if( HPMHooks.count.HP_intif_Mail_requestinbox_post ) { - int (*postHookFunc) (int retVal___, int *char_id, unsigned char *flag); + int (*postHookFunc) (int retVal___, int char_id, unsigned char flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_requestinbox_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_requestinbox_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &flag); + retVal___ = postHookFunc(retVal___, char_id, flag); } } return retVal___; @@ -32085,10 +32180,10 @@ int HP_intif_Mail_read(int mail_id) { retVal___ = HPMHooks.source.intif.Mail_read(mail_id); } if( HPMHooks.count.HP_intif_Mail_read_post ) { - int (*postHookFunc) (int retVal___, int *mail_id); + int (*postHookFunc) (int retVal___, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_read_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_read_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &mail_id); + retVal___ = postHookFunc(retVal___, mail_id); } } return retVal___; @@ -32112,10 +32207,10 @@ int HP_intif_Mail_getattach(int char_id, int mail_id) { retVal___ = HPMHooks.source.intif.Mail_getattach(char_id, mail_id); } if( HPMHooks.count.HP_intif_Mail_getattach_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *mail_id); + int (*postHookFunc) (int retVal___, int char_id, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_getattach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_getattach_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &mail_id); + retVal___ = postHookFunc(retVal___, char_id, mail_id); } } return retVal___; @@ -32139,10 +32234,10 @@ int HP_intif_Mail_delete(int char_id, int mail_id) { retVal___ = HPMHooks.source.intif.Mail_delete(char_id, mail_id); } if( HPMHooks.count.HP_intif_Mail_delete_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *mail_id); + int (*postHookFunc) (int retVal___, int char_id, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &mail_id); + retVal___ = postHookFunc(retVal___, char_id, mail_id); } } return retVal___; @@ -32166,10 +32261,10 @@ int HP_intif_Mail_return(int char_id, int mail_id) { retVal___ = HPMHooks.source.intif.Mail_return(char_id, mail_id); } if( HPMHooks.count.HP_intif_Mail_return_post ) { - int (*postHookFunc) (int retVal___, int *char_id, int *mail_id); + int (*postHookFunc) (int retVal___, int char_id, int mail_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_return_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_return_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &mail_id); + retVal___ = postHookFunc(retVal___, char_id, mail_id); } } return retVal___; @@ -32178,11 +32273,11 @@ int HP_intif_Mail_send(int account_id, struct mail_message *msg) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_Mail_send_pre ) { - int (*preHookFunc) (int *account_id, struct mail_message *msg); + int (*preHookFunc) (int *account_id, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_Mail_send_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, msg); + retVal___ = preHookFunc(&account_id, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32193,10 +32288,10 @@ int HP_intif_Mail_send(int account_id, struct mail_message *msg) { retVal___ = HPMHooks.source.intif.Mail_send(account_id, msg); } if( HPMHooks.count.HP_intif_Mail_send_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct mail_message *msg); + int (*postHookFunc) (int retVal___, int account_id, struct mail_message *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Mail_send_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, msg); + retVal___ = postHookFunc(retVal___, account_id, msg); } } return retVal___; @@ -32205,11 +32300,11 @@ int HP_intif_Auction_requestlist(int char_id, short type, int price, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_Auction_requestlist_pre ) { - int (*preHookFunc) (int *char_id, short *type, int *price, const char *searchtext, short *page); + int (*preHookFunc) (int *char_id, short *type, int *price, const char **searchtext, short *page); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_requestlist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_Auction_requestlist_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, &type, &price, searchtext, &page); + retVal___ = preHookFunc(&char_id, &type, &price, &searchtext, &page); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32220,10 +32315,10 @@ int HP_intif_Auction_requestlist(int char_id, short type, int price, const char retVal___ = HPMHooks.source.intif.Auction_requestlist(char_id, type, price, searchtext, page); } if( HPMHooks.count.HP_intif_Auction_requestlist_post ) { - int (*postHookFunc) (int retVal___, int *char_id, short *type, int *price, const char *searchtext, short *page); + int (*postHookFunc) (int retVal___, int char_id, short type, int price, const char *searchtext, short page); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_requestlist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Auction_requestlist_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &type, &price, searchtext, &page); + retVal___ = postHookFunc(retVal___, char_id, type, price, searchtext, page); } } return retVal___; @@ -32232,11 +32327,11 @@ int HP_intif_Auction_register(struct auction_data *auction) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_Auction_register_pre ) { - int (*preHookFunc) (struct auction_data *auction); + int (*preHookFunc) (struct auction_data **auction); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_register_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_Auction_register_pre[hIndex].func; - retVal___ = preHookFunc(auction); + retVal___ = preHookFunc(&auction); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32274,10 +32369,10 @@ int HP_intif_Auction_cancel(int char_id, unsigned int auction_id) { retVal___ = HPMHooks.source.intif.Auction_cancel(char_id, auction_id); } if( HPMHooks.count.HP_intif_Auction_cancel_post ) { - int (*postHookFunc) (int retVal___, int *char_id, unsigned int *auction_id); + int (*postHookFunc) (int retVal___, int char_id, unsigned int auction_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_cancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Auction_cancel_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &auction_id); + retVal___ = postHookFunc(retVal___, char_id, auction_id); } } return retVal___; @@ -32301,10 +32396,10 @@ int HP_intif_Auction_close(int char_id, unsigned int auction_id) { retVal___ = HPMHooks.source.intif.Auction_close(char_id, auction_id); } if( HPMHooks.count.HP_intif_Auction_close_post ) { - int (*postHookFunc) (int retVal___, int *char_id, unsigned int *auction_id); + int (*postHookFunc) (int retVal___, int char_id, unsigned int auction_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Auction_close_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &auction_id); + retVal___ = postHookFunc(retVal___, char_id, auction_id); } } return retVal___; @@ -32313,11 +32408,11 @@ int HP_intif_Auction_bid(int char_id, const char *name, unsigned int auction_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_Auction_bid_pre ) { - int (*preHookFunc) (int *char_id, const char *name, unsigned int *auction_id, int *bid); + int (*preHookFunc) (int *char_id, const char **name, unsigned int *auction_id, int *bid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_bid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_Auction_bid_pre[hIndex].func; - retVal___ = preHookFunc(&char_id, name, &auction_id, &bid); + retVal___ = preHookFunc(&char_id, &name, &auction_id, &bid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32328,10 +32423,10 @@ int HP_intif_Auction_bid(int char_id, const char *name, unsigned int auction_id, retVal___ = HPMHooks.source.intif.Auction_bid(char_id, name, auction_id, bid); } if( HPMHooks.count.HP_intif_Auction_bid_post ) { - int (*postHookFunc) (int retVal___, int *char_id, const char *name, unsigned int *auction_id, int *bid); + int (*postHookFunc) (int retVal___, int char_id, const char *name, unsigned int auction_id, int bid); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_bid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_Auction_bid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, name, &auction_id, &bid); + retVal___ = postHookFunc(retVal___, char_id, name, auction_id, bid); } } return retVal___; @@ -32340,11 +32435,11 @@ int HP_intif_elemental_create(struct s_elemental *ele) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_elemental_create_pre ) { - int (*preHookFunc) (struct s_elemental *ele); + int (*preHookFunc) (struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_elemental_create_pre[hIndex].func; - retVal___ = preHookFunc(ele); + retVal___ = preHookFunc(&ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32382,10 +32477,10 @@ int HP_intif_elemental_request(int ele_id, int char_id) { retVal___ = HPMHooks.source.intif.elemental_request(ele_id, char_id); } if( HPMHooks.count.HP_intif_elemental_request_post ) { - int (*postHookFunc) (int retVal___, int *ele_id, int *char_id); + int (*postHookFunc) (int retVal___, int ele_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_request_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_elemental_request_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ele_id, &char_id); + retVal___ = postHookFunc(retVal___, ele_id, char_id); } } return retVal___; @@ -32409,10 +32504,10 @@ int HP_intif_elemental_delete(int ele_id) { retVal___ = HPMHooks.source.intif.elemental_delete(ele_id); } if( HPMHooks.count.HP_intif_elemental_delete_post ) { - int (*postHookFunc) (int retVal___, int *ele_id); + int (*postHookFunc) (int retVal___, int ele_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_elemental_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ele_id); + retVal___ = postHookFunc(retVal___, ele_id); } } return retVal___; @@ -32421,11 +32516,11 @@ int HP_intif_elemental_save(struct s_elemental *ele) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_elemental_save_pre ) { - int (*preHookFunc) (struct s_elemental *ele); + int (*preHookFunc) (struct s_elemental **ele); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_elemental_save_pre[hIndex].func; - retVal___ = preHookFunc(ele); + retVal___ = preHookFunc(&ele); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32447,11 +32542,11 @@ int HP_intif_elemental_save(struct s_elemental *ele) { void HP_intif_request_accinfo(int u_fd, int aid, int group_lv, char *query) { int hIndex = 0; if( HPMHooks.count.HP_intif_request_accinfo_pre ) { - void (*preHookFunc) (int *u_fd, int *aid, int *group_lv, char *query); + void (*preHookFunc) (int *u_fd, int *aid, int *group_lv, char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_accinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_intif_request_accinfo_pre[hIndex].func; - preHookFunc(&u_fd, &aid, &group_lv, query); + preHookFunc(&u_fd, &aid, &group_lv, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -32462,10 +32557,10 @@ void HP_intif_request_accinfo(int u_fd, int aid, int group_lv, char *query) { HPMHooks.source.intif.request_accinfo(u_fd, aid, group_lv, query); } if( HPMHooks.count.HP_intif_request_accinfo_post ) { - void (*postHookFunc) (int *u_fd, int *aid, int *group_lv, char *query); + void (*postHookFunc) (int u_fd, int aid, int group_lv, char *query); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_accinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_request_accinfo_post[hIndex].func; - postHookFunc(&u_fd, &aid, &group_lv, query); + postHookFunc(u_fd, aid, group_lv, query); } } return; @@ -32515,10 +32610,10 @@ void HP_intif_pWisMessage(int fd) { HPMHooks.source.intif.pWisMessage(fd); } if( HPMHooks.count.HP_intif_pWisMessage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pWisMessage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32541,10 +32636,10 @@ void HP_intif_pWisEnd(int fd) { HPMHooks.source.intif.pWisEnd(fd); } if( HPMHooks.count.HP_intif_pWisEnd_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisEnd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pWisEnd_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32553,12 +32648,12 @@ int HP_intif_pWisToGM_sub(struct map_session_data *sd, va_list va) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_intif_pWisToGM_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list va); + int (*preHookFunc) (struct map_session_data **sd, va_list va); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_sub_pre; hIndex++ ) { va_list va___copy; va_copy(va___copy, va); preHookFunc = HPMHooks.list.HP_intif_pWisToGM_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, va___copy); + retVal___ = preHookFunc(&sd, va___copy); va_end(va___copy); } if( *HPMforce_return ) { @@ -32600,10 +32695,10 @@ void HP_intif_pWisToGM(int fd) { HPMHooks.source.intif.pWisToGM(fd); } if( HPMHooks.count.HP_intif_pWisToGM_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pWisToGM_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32626,10 +32721,10 @@ void HP_intif_pRegisters(int fd) { HPMHooks.source.intif.pRegisters(fd); } if( HPMHooks.count.HP_intif_pRegisters_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRegisters_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pRegisters_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32652,10 +32747,10 @@ void HP_intif_pChangeNameOk(int fd) { HPMHooks.source.intif.pChangeNameOk(fd); } if( HPMHooks.count.HP_intif_pChangeNameOk_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pChangeNameOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pChangeNameOk_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32678,10 +32773,10 @@ void HP_intif_pMessageToFD(int fd) { HPMHooks.source.intif.pMessageToFD(fd); } if( HPMHooks.count.HP_intif_pMessageToFD_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMessageToFD_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMessageToFD_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32704,10 +32799,10 @@ void HP_intif_pLoadGuildStorage(int fd) { HPMHooks.source.intif.pLoadGuildStorage(fd); } if( HPMHooks.count.HP_intif_pLoadGuildStorage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pLoadGuildStorage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pLoadGuildStorage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32730,10 +32825,10 @@ void HP_intif_pSaveGuildStorage(int fd) { HPMHooks.source.intif.pSaveGuildStorage(fd); } if( HPMHooks.count.HP_intif_pSaveGuildStorage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveGuildStorage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pSaveGuildStorage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32756,10 +32851,10 @@ void HP_intif_pPartyCreated(int fd) { HPMHooks.source.intif.pPartyCreated(fd); } if( HPMHooks.count.HP_intif_pPartyCreated_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyCreated_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyCreated_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32782,10 +32877,10 @@ void HP_intif_pPartyInfo(int fd) { HPMHooks.source.intif.pPartyInfo(fd); } if( HPMHooks.count.HP_intif_pPartyInfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyInfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32808,10 +32903,10 @@ void HP_intif_pPartyMemberAdded(int fd) { HPMHooks.source.intif.pPartyMemberAdded(fd); } if( HPMHooks.count.HP_intif_pPartyMemberAdded_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberAdded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyMemberAdded_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32834,10 +32929,10 @@ void HP_intif_pPartyOptionChanged(int fd) { HPMHooks.source.intif.pPartyOptionChanged(fd); } if( HPMHooks.count.HP_intif_pPartyOptionChanged_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyOptionChanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyOptionChanged_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32860,10 +32955,10 @@ void HP_intif_pPartyMemberWithdraw(int fd) { HPMHooks.source.intif.pPartyMemberWithdraw(fd); } if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberWithdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyMemberWithdraw_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32886,10 +32981,10 @@ void HP_intif_pPartyMove(int fd) { HPMHooks.source.intif.pPartyMove(fd); } if( HPMHooks.count.HP_intif_pPartyMove_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyMove_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32912,10 +33007,10 @@ void HP_intif_pPartyBroken(int fd) { HPMHooks.source.intif.pPartyBroken(fd); } if( HPMHooks.count.HP_intif_pPartyBroken_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyBroken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyBroken_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32938,10 +33033,10 @@ void HP_intif_pPartyMessage(int fd) { HPMHooks.source.intif.pPartyMessage(fd); } if( HPMHooks.count.HP_intif_pPartyMessage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pPartyMessage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32964,10 +33059,10 @@ void HP_intif_pGuildCreated(int fd) { HPMHooks.source.intif.pGuildCreated(fd); } if( HPMHooks.count.HP_intif_pGuildCreated_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCreated_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildCreated_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -32990,10 +33085,10 @@ void HP_intif_pGuildInfo(int fd) { HPMHooks.source.intif.pGuildInfo(fd); } if( HPMHooks.count.HP_intif_pGuildInfo_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildInfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildInfo_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33016,10 +33111,10 @@ void HP_intif_pGuildMemberAdded(int fd) { HPMHooks.source.intif.pGuildMemberAdded(fd); } if( HPMHooks.count.HP_intif_pGuildMemberAdded_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberAdded_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMemberAdded_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33042,10 +33137,10 @@ void HP_intif_pGuildMemberWithdraw(int fd) { HPMHooks.source.intif.pGuildMemberWithdraw(fd); } if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberWithdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMemberWithdraw_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33068,10 +33163,10 @@ void HP_intif_pGuildMemberInfoShort(int fd) { HPMHooks.source.intif.pGuildMemberInfoShort(fd); } if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoShort_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoShort_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33094,10 +33189,10 @@ void HP_intif_pGuildBroken(int fd) { HPMHooks.source.intif.pGuildBroken(fd); } if( HPMHooks.count.HP_intif_pGuildBroken_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBroken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildBroken_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33120,10 +33215,10 @@ void HP_intif_pGuildMessage(int fd) { HPMHooks.source.intif.pGuildMessage(fd); } if( HPMHooks.count.HP_intif_pGuildMessage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMessage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33146,10 +33241,10 @@ void HP_intif_pGuildBasicInfoChanged(int fd) { HPMHooks.source.intif.pGuildBasicInfoChanged(fd); } if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildBasicInfoChanged_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33172,10 +33267,10 @@ void HP_intif_pGuildMemberInfoChanged(int fd) { HPMHooks.source.intif.pGuildMemberInfoChanged(fd); } if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoChanged_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33198,10 +33293,10 @@ void HP_intif_pGuildPosition(int fd) { HPMHooks.source.intif.pGuildPosition(fd); } if( HPMHooks.count.HP_intif_pGuildPosition_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildPosition_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildPosition_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33224,10 +33319,10 @@ void HP_intif_pGuildSkillUp(int fd) { HPMHooks.source.intif.pGuildSkillUp(fd); } if( HPMHooks.count.HP_intif_pGuildSkillUp_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildSkillUp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildSkillUp_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33250,10 +33345,10 @@ void HP_intif_pGuildAlliance(int fd) { HPMHooks.source.intif.pGuildAlliance(fd); } if( HPMHooks.count.HP_intif_pGuildAlliance_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildAlliance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildAlliance_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33276,10 +33371,10 @@ void HP_intif_pGuildNotice(int fd) { HPMHooks.source.intif.pGuildNotice(fd); } if( HPMHooks.count.HP_intif_pGuildNotice_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildNotice_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildNotice_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33302,10 +33397,10 @@ void HP_intif_pGuildEmblem(int fd) { HPMHooks.source.intif.pGuildEmblem(fd); } if( HPMHooks.count.HP_intif_pGuildEmblem_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildEmblem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildEmblem_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33328,10 +33423,10 @@ void HP_intif_pGuildCastleDataLoad(int fd) { HPMHooks.source.intif.pGuildCastleDataLoad(fd); } if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCastleDataLoad_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildCastleDataLoad_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33354,10 +33449,10 @@ void HP_intif_pGuildMasterChanged(int fd) { HPMHooks.source.intif.pGuildMasterChanged(fd); } if( HPMHooks.count.HP_intif_pGuildMasterChanged_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMasterChanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pGuildMasterChanged_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33380,10 +33475,10 @@ void HP_intif_pQuestLog(int fd) { HPMHooks.source.intif.pQuestLog(fd); } if( HPMHooks.count.HP_intif_pQuestLog_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestLog_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pQuestLog_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33406,10 +33501,10 @@ void HP_intif_pQuestSave(int fd) { HPMHooks.source.intif.pQuestSave(fd); } if( HPMHooks.count.HP_intif_pQuestSave_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestSave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pQuestSave_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33432,10 +33527,10 @@ void HP_intif_pMailInboxReceived(int fd) { HPMHooks.source.intif.pMailInboxReceived(fd); } if( HPMHooks.count.HP_intif_pMailInboxReceived_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailInboxReceived_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailInboxReceived_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33458,10 +33553,10 @@ void HP_intif_pMailNew(int fd) { HPMHooks.source.intif.pMailNew(fd); } if( HPMHooks.count.HP_intif_pMailNew_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailNew_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailNew_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33484,10 +33579,10 @@ void HP_intif_pMailGetAttach(int fd) { HPMHooks.source.intif.pMailGetAttach(fd); } if( HPMHooks.count.HP_intif_pMailGetAttach_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailGetAttach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailGetAttach_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33510,10 +33605,10 @@ void HP_intif_pMailDelete(int fd) { HPMHooks.source.intif.pMailDelete(fd); } if( HPMHooks.count.HP_intif_pMailDelete_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailDelete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailDelete_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33536,10 +33631,10 @@ void HP_intif_pMailReturn(int fd) { HPMHooks.source.intif.pMailReturn(fd); } if( HPMHooks.count.HP_intif_pMailReturn_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailReturn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailReturn_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33562,10 +33657,10 @@ void HP_intif_pMailSend(int fd) { HPMHooks.source.intif.pMailSend(fd); } if( HPMHooks.count.HP_intif_pMailSend_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailSend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMailSend_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33588,10 +33683,10 @@ void HP_intif_pAuctionResults(int fd) { HPMHooks.source.intif.pAuctionResults(fd); } if( HPMHooks.count.HP_intif_pAuctionResults_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionResults_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionResults_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33614,10 +33709,10 @@ void HP_intif_pAuctionRegister(int fd) { HPMHooks.source.intif.pAuctionRegister(fd); } if( HPMHooks.count.HP_intif_pAuctionRegister_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionRegister_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionRegister_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33640,10 +33735,10 @@ void HP_intif_pAuctionCancel(int fd) { HPMHooks.source.intif.pAuctionCancel(fd); } if( HPMHooks.count.HP_intif_pAuctionCancel_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionCancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionCancel_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33666,10 +33761,10 @@ void HP_intif_pAuctionClose(int fd) { HPMHooks.source.intif.pAuctionClose(fd); } if( HPMHooks.count.HP_intif_pAuctionClose_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionClose_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionClose_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33692,10 +33787,10 @@ void HP_intif_pAuctionMessage(int fd) { HPMHooks.source.intif.pAuctionMessage(fd); } if( HPMHooks.count.HP_intif_pAuctionMessage_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionMessage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionMessage_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33718,10 +33813,10 @@ void HP_intif_pAuctionBid(int fd) { HPMHooks.source.intif.pAuctionBid(fd); } if( HPMHooks.count.HP_intif_pAuctionBid_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionBid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pAuctionBid_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33744,10 +33839,10 @@ void HP_intif_pItembound_ack(int fd) { HPMHooks.source.intif.pItembound_ack(fd); } if( HPMHooks.count.HP_intif_pItembound_ack_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pItembound_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pItembound_ack_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33770,10 +33865,10 @@ void HP_intif_pMercenaryReceived(int fd) { HPMHooks.source.intif.pMercenaryReceived(fd); } if( HPMHooks.count.HP_intif_pMercenaryReceived_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryReceived_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMercenaryReceived_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33796,10 +33891,10 @@ void HP_intif_pMercenaryDeleted(int fd) { HPMHooks.source.intif.pMercenaryDeleted(fd); } if( HPMHooks.count.HP_intif_pMercenaryDeleted_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryDeleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMercenaryDeleted_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33822,10 +33917,10 @@ void HP_intif_pMercenarySaved(int fd) { HPMHooks.source.intif.pMercenarySaved(fd); } if( HPMHooks.count.HP_intif_pMercenarySaved_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenarySaved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pMercenarySaved_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33848,10 +33943,10 @@ void HP_intif_pElementalReceived(int fd) { HPMHooks.source.intif.pElementalReceived(fd); } if( HPMHooks.count.HP_intif_pElementalReceived_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalReceived_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pElementalReceived_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33874,10 +33969,10 @@ void HP_intif_pElementalDeleted(int fd) { HPMHooks.source.intif.pElementalDeleted(fd); } if( HPMHooks.count.HP_intif_pElementalDeleted_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalDeleted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pElementalDeleted_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33900,10 +33995,10 @@ void HP_intif_pElementalSaved(int fd) { HPMHooks.source.intif.pElementalSaved(fd); } if( HPMHooks.count.HP_intif_pElementalSaved_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalSaved_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pElementalSaved_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33926,10 +34021,10 @@ void HP_intif_pCreatePet(int fd) { HPMHooks.source.intif.pCreatePet(fd); } if( HPMHooks.count.HP_intif_pCreatePet_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreatePet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pCreatePet_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33952,10 +34047,10 @@ void HP_intif_pRecvPetData(int fd) { HPMHooks.source.intif.pRecvPetData(fd); } if( HPMHooks.count.HP_intif_pRecvPetData_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvPetData_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pRecvPetData_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -33978,10 +34073,10 @@ void HP_intif_pSavePetOk(int fd) { HPMHooks.source.intif.pSavePetOk(fd); } if( HPMHooks.count.HP_intif_pSavePetOk_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSavePetOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pSavePetOk_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34004,10 +34099,10 @@ void HP_intif_pDeletePetOk(int fd) { HPMHooks.source.intif.pDeletePetOk(fd); } if( HPMHooks.count.HP_intif_pDeletePetOk_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeletePetOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pDeletePetOk_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34030,10 +34125,10 @@ void HP_intif_pCreateHomunculus(int fd) { HPMHooks.source.intif.pCreateHomunculus(fd); } if( HPMHooks.count.HP_intif_pCreateHomunculus_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreateHomunculus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pCreateHomunculus_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34056,10 +34151,10 @@ void HP_intif_pRecvHomunculusData(int fd) { HPMHooks.source.intif.pRecvHomunculusData(fd); } if( HPMHooks.count.HP_intif_pRecvHomunculusData_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvHomunculusData_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pRecvHomunculusData_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34082,10 +34177,10 @@ void HP_intif_pSaveHomunculusOk(int fd) { HPMHooks.source.intif.pSaveHomunculusOk(fd); } if( HPMHooks.count.HP_intif_pSaveHomunculusOk_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveHomunculusOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pSaveHomunculusOk_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34108,10 +34203,10 @@ void HP_intif_pDeleteHomunculusOk(int fd) { HPMHooks.source.intif.pDeleteHomunculusOk(fd); } if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeleteHomunculusOk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_intif_pDeleteHomunculusOk_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -34135,10 +34230,10 @@ void HP_ircbot_init(bool minimal) { HPMHooks.source.ircbot.init(minimal); } if( HPMHooks.count.HP_ircbot_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -34188,10 +34283,10 @@ int HP_ircbot_parse(int fd) { retVal___ = HPMHooks.source.ircbot.parse(fd); } if( HPMHooks.count.HP_ircbot_parse_post ) { - int (*postHookFunc) (int retVal___, int *fd); + int (*postHookFunc) (int retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -34199,11 +34294,11 @@ int HP_ircbot_parse(int fd) { void HP_ircbot_parse_sub(int fd, char *str) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_parse_sub_pre ) { - void (*preHookFunc) (int *fd, char *str); + void (*preHookFunc) (int *fd, char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_parse_sub_pre[hIndex].func; - preHookFunc(&fd, str); + preHookFunc(&fd, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34214,10 +34309,10 @@ void HP_ircbot_parse_sub(int fd, char *str) { HPMHooks.source.ircbot.parse_sub(fd, str); } if( HPMHooks.count.HP_ircbot_parse_sub_post ) { - void (*postHookFunc) (int *fd, char *str); + void (*postHookFunc) (int fd, char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_parse_sub_post[hIndex].func; - postHookFunc(&fd, str); + postHookFunc(fd, str); } } return; @@ -34225,11 +34320,11 @@ void HP_ircbot_parse_sub(int fd, char *str) { void HP_ircbot_parse_source(char *source, char *nick, char *ident, char *host) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_parse_source_pre ) { - void (*preHookFunc) (char *source, char *nick, char *ident, char *host); + void (*preHookFunc) (char **source, char **nick, char **ident, char **host); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_source_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_parse_source_pre[hIndex].func; - preHookFunc(source, nick, ident, host); + preHookFunc(&source, &nick, &ident, &host); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34252,11 +34347,11 @@ struct irc_func* HP_ircbot_func_search(char *function_name) { int hIndex = 0; struct irc_func* retVal___ = NULL; if( HPMHooks.count.HP_ircbot_func_search_pre ) { - struct irc_func* (*preHookFunc) (char *function_name); + struct irc_func* (*preHookFunc) (char **function_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_func_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_func_search_pre[hIndex].func; - retVal___ = preHookFunc(function_name); + retVal___ = preHookFunc(&function_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34294,10 +34389,10 @@ int HP_ircbot_connect_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.ircbot.connect_timer(tid, tick, id, data); } if( HPMHooks.count.HP_ircbot_connect_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_connect_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_connect_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -34321,10 +34416,10 @@ int HP_ircbot_identify_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.ircbot.identify_timer(tid, tick, id, data); } if( HPMHooks.count.HP_ircbot_identify_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_identify_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_identify_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -34348,22 +34443,75 @@ int HP_ircbot_join_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.ircbot.join_timer(tid, tick, id, data); } if( HPMHooks.count.HP_ircbot_join_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_join_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_join_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; } -void HP_ircbot_send(char *str) { +int HP_ircbot_queue_timer(int tid, int64 tick, int id, intptr_t data) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_ircbot_queue_timer_pre ) { + int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_timer_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_ircbot_queue_timer_pre[hIndex].func; + retVal___ = preHookFunc(&tid, &tick, &id, &data); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.ircbot.queue_timer(tid, tick, id, data); + } + if( HPMHooks.count.HP_ircbot_queue_timer_post ) { + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_timer_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_ircbot_queue_timer_post[hIndex].func; + retVal___ = postHookFunc(retVal___, tid, tick, id, data); + } + } + return retVal___; +} +void HP_ircbot_queue(char *str) { + int hIndex = 0; + if( HPMHooks.count.HP_ircbot_queue_pre ) { + void (*preHookFunc) (char **str); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_ircbot_queue_pre[hIndex].func; + preHookFunc(&str); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.ircbot.queue(str); + } + if( HPMHooks.count.HP_ircbot_queue_post ) { + void (*postHookFunc) (char *str); + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_ircbot_queue_post[hIndex].func; + postHookFunc(str); + } + } + return; +} +void HP_ircbot_send(char *str, bool force) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_send_pre ) { - void (*preHookFunc) (char *str); + void (*preHookFunc) (char **str, bool *force); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_send_pre[hIndex].func; - preHookFunc(str); + preHookFunc(&str, &force); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34371,13 +34519,13 @@ void HP_ircbot_send(char *str) { } } { - HPMHooks.source.ircbot.send(str); + HPMHooks.source.ircbot.send(str, force); } if( HPMHooks.count.HP_ircbot_send_post ) { - void (*postHookFunc) (char *str); + void (*postHookFunc) (char *str, bool force); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_send_post[hIndex].func; - postHookFunc(str); + postHookFunc(str, force); } } return; @@ -34385,11 +34533,11 @@ void HP_ircbot_send(char *str) { void HP_ircbot_relay(const char *name, const char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_relay_pre ) { - void (*preHookFunc) (const char *name, const char *msg); + void (*preHookFunc) (const char **name, const char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_relay_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_relay_pre[hIndex].func; - preHookFunc(name, msg); + preHookFunc(&name, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34411,11 +34559,11 @@ void HP_ircbot_relay(const char *name, const char *msg) { void HP_ircbot_pong(int fd, char *cmd, char *source, char *target, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_pong_pre ) { - void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_pong_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_pong_pre[hIndex].func; - preHookFunc(&fd, cmd, source, target, msg); + preHookFunc(&fd, &cmd, &source, &target, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34426,10 +34574,10 @@ void HP_ircbot_pong(int fd, char *cmd, char *source, char *target, char *msg) { HPMHooks.source.ircbot.pong(fd, cmd, source, target, msg); } if( HPMHooks.count.HP_ircbot_pong_post ) { - void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_pong_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_pong_post[hIndex].func; - postHookFunc(&fd, cmd, source, target, msg); + postHookFunc(fd, cmd, source, target, msg); } } return; @@ -34437,11 +34585,11 @@ void HP_ircbot_pong(int fd, char *cmd, char *source, char *target, char *msg) { void HP_ircbot_privmsg(int fd, char *cmd, char *source, char *target, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_privmsg_pre ) { - void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_privmsg_pre[hIndex].func; - preHookFunc(&fd, cmd, source, target, msg); + preHookFunc(&fd, &cmd, &source, &target, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34452,10 +34600,36 @@ void HP_ircbot_privmsg(int fd, char *cmd, char *source, char *target, char *msg) HPMHooks.source.ircbot.privmsg(fd, cmd, source, target, msg); } if( HPMHooks.count.HP_ircbot_privmsg_post ) { - void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_privmsg_post[hIndex].func; - postHookFunc(&fd, cmd, source, target, msg); + postHookFunc(fd, cmd, source, target, msg); + } + } + return; +} +void HP_ircbot_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) { + int hIndex = 0; + if( HPMHooks.count.HP_ircbot_privmsg_ctcp_pre ) { + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_ctcp_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_ircbot_privmsg_ctcp_pre[hIndex].func; + preHookFunc(&fd, &cmd, &source, &target, &msg); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.ircbot.privmsg_ctcp(fd, cmd, source, target, msg); + } + if( HPMHooks.count.HP_ircbot_privmsg_ctcp_post ) { + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); + for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_ctcp_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_ircbot_privmsg_ctcp_post[hIndex].func; + postHookFunc(fd, cmd, source, target, msg); } } return; @@ -34463,11 +34637,11 @@ void HP_ircbot_privmsg(int fd, char *cmd, char *source, char *target, char *msg) void HP_ircbot_userjoin(int fd, char *cmd, char *source, char *target, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_userjoin_pre ) { - void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userjoin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_userjoin_pre[hIndex].func; - preHookFunc(&fd, cmd, source, target, msg); + preHookFunc(&fd, &cmd, &source, &target, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34478,10 +34652,10 @@ void HP_ircbot_userjoin(int fd, char *cmd, char *source, char *target, char *msg HPMHooks.source.ircbot.userjoin(fd, cmd, source, target, msg); } if( HPMHooks.count.HP_ircbot_userjoin_post ) { - void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userjoin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_userjoin_post[hIndex].func; - postHookFunc(&fd, cmd, source, target, msg); + postHookFunc(fd, cmd, source, target, msg); } } return; @@ -34489,11 +34663,11 @@ void HP_ircbot_userjoin(int fd, char *cmd, char *source, char *target, char *msg void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_userleave_pre ) { - void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userleave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_userleave_pre[hIndex].func; - preHookFunc(&fd, cmd, source, target, msg); + preHookFunc(&fd, &cmd, &source, &target, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34504,10 +34678,10 @@ void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *ms HPMHooks.source.ircbot.userleave(fd, cmd, source, target, msg); } if( HPMHooks.count.HP_ircbot_userleave_post ) { - void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userleave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_userleave_post[hIndex].func; - postHookFunc(&fd, cmd, source, target, msg); + postHookFunc(fd, cmd, source, target, msg); } } return; @@ -34515,11 +34689,11 @@ void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *ms void HP_ircbot_usernick(int fd, char *cmd, char *source, char *target, char *msg) { int hIndex = 0; if( HPMHooks.count.HP_ircbot_usernick_pre ) { - void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_usernick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_ircbot_usernick_pre[hIndex].func; - preHookFunc(&fd, cmd, source, target, msg); + preHookFunc(&fd, &cmd, &source, &target, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34530,10 +34704,10 @@ void HP_ircbot_usernick(int fd, char *cmd, char *source, char *target, char *msg HPMHooks.source.ircbot.usernick(fd, cmd, source, target, msg); } if( HPMHooks.count.HP_ircbot_usernick_post ) { - void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg); + void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg); for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_usernick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_ircbot_usernick_post[hIndex].func; - postHookFunc(&fd, cmd, source, target, msg); + postHookFunc(fd, cmd, source, target, msg); } } return; @@ -34557,10 +34731,10 @@ void HP_itemdb_init(bool minimal) { HPMHooks.source.itemdb.init(minimal); } if( HPMHooks.count.HP_itemdb_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -34724,11 +34898,11 @@ void HP_itemdb_read_packages(void) { void HP_itemdb_write_cached_packages(const char *config_filename) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_write_cached_packages_pre ) { - void (*preHookFunc) (const char *config_filename); + void (*preHookFunc) (const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_write_cached_packages_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_write_cached_packages_pre[hIndex].func; - preHookFunc(config_filename); + preHookFunc(&config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34751,11 +34925,11 @@ bool HP_itemdb_read_cached_packages(const char *config_filename) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_itemdb_read_cached_packages_pre ) { - bool (*preHookFunc) (const char *config_filename); + bool (*preHookFunc) (const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_cached_packages_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_read_cached_packages_pre[hIndex].func; - retVal___ = preHookFunc(config_filename); + retVal___ = preHookFunc(&config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34778,11 +34952,11 @@ struct item_data* HP_itemdb_name2id(const char *str) { int hIndex = 0; struct item_data* retVal___ = NULL; if( HPMHooks.count.HP_itemdb_name2id_pre ) { - struct item_data* (*preHookFunc) (const char *str); + struct item_data* (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_name2id_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34805,11 +34979,11 @@ struct item_data* HP_itemdb_search_name(const char *name) { int hIndex = 0; struct item_data* retVal___ = NULL; if( HPMHooks.count.HP_itemdb_search_name_pre ) { - struct item_data* (*preHookFunc) (const char *name); + struct item_data* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_search_name_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34832,11 +35006,11 @@ int HP_itemdb_search_name_array(struct item_data **data, int size, const char *s int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_search_name_array_pre ) { - int (*preHookFunc) (struct item_data **data, int *size, const char *str, int *flag); + int (*preHookFunc) (struct item_data ***data, int *size, const char **str, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_array_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_search_name_array_pre[hIndex].func; - retVal___ = preHookFunc(data, &size, str, &flag); + retVal___ = preHookFunc(&data, &size, &str, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34847,10 +35021,10 @@ int HP_itemdb_search_name_array(struct item_data **data, int size, const char *s retVal___ = HPMHooks.source.itemdb.search_name_array(data, size, str, flag); } if( HPMHooks.count.HP_itemdb_search_name_array_post ) { - int (*postHookFunc) (int retVal___, struct item_data **data, int *size, const char *str, int *flag); + int (*postHookFunc) (int retVal___, struct item_data **data, int size, const char *str, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_array_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_search_name_array_post[hIndex].func; - retVal___ = postHookFunc(retVal___, data, &size, str, &flag); + retVal___ = postHookFunc(retVal___, data, size, str, flag); } } return retVal___; @@ -34874,10 +35048,10 @@ struct item_data* HP_itemdb_load(int nameid) { retVal___ = HPMHooks.source.itemdb.load(nameid); } if( HPMHooks.count.HP_itemdb_load_post ) { - struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid); + struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_load_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_load_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -34901,10 +35075,10 @@ struct item_data* HP_itemdb_search(int nameid) { retVal___ = HPMHooks.source.itemdb.search(nameid); } if( HPMHooks.count.HP_itemdb_search_post ) { - struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid); + struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -34928,10 +35102,10 @@ struct item_data* HP_itemdb_exists(int nameid) { retVal___ = HPMHooks.source.itemdb.exists(nameid); } if( HPMHooks.count.HP_itemdb_exists_post ) { - struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid); + struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_exists_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_exists_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -34940,11 +35114,11 @@ bool HP_itemdb_in_group(struct item_group *group, int nameid) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_itemdb_in_group_pre ) { - bool (*preHookFunc) (struct item_group *group, int *nameid); + bool (*preHookFunc) (struct item_group **group, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_in_group_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_in_group_pre[hIndex].func; - retVal___ = preHookFunc(group, &nameid); + retVal___ = preHookFunc(&group, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34955,10 +35129,10 @@ bool HP_itemdb_in_group(struct item_group *group, int nameid) { retVal___ = HPMHooks.source.itemdb.in_group(group, nameid); } if( HPMHooks.count.HP_itemdb_in_group_post ) { - bool (*postHookFunc) (bool retVal___, struct item_group *group, int *nameid); + bool (*postHookFunc) (bool retVal___, struct item_group *group, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_in_group_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_in_group_post[hIndex].func; - retVal___ = postHookFunc(retVal___, group, &nameid); + retVal___ = postHookFunc(retVal___, group, nameid); } } return retVal___; @@ -34967,11 +35141,11 @@ int HP_itemdb_group_item(struct item_group *group) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_group_item_pre ) { - int (*preHookFunc) (struct item_group *group); + int (*preHookFunc) (struct item_group **group); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_group_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_group_item_pre[hIndex].func; - retVal___ = preHookFunc(group); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -34994,11 +35168,11 @@ int HP_itemdb_chain_item(unsigned short chain_id, int *rate) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_chain_item_pre ) { - int (*preHookFunc) (unsigned short *chain_id, int *rate); + int (*preHookFunc) (unsigned short *chain_id, int **rate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_chain_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_chain_item_pre[hIndex].func; - retVal___ = preHookFunc(&chain_id, rate); + retVal___ = preHookFunc(&chain_id, &rate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35009,10 +35183,10 @@ int HP_itemdb_chain_item(unsigned short chain_id, int *rate) { retVal___ = HPMHooks.source.itemdb.chain_item(chain_id, rate); } if( HPMHooks.count.HP_itemdb_chain_item_post ) { - int (*postHookFunc) (int retVal___, unsigned short *chain_id, int *rate); + int (*postHookFunc) (int retVal___, unsigned short chain_id, int *rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_chain_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_chain_item_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &chain_id, rate); + retVal___ = postHookFunc(retVal___, chain_id, rate); } } return retVal___; @@ -35020,11 +35194,11 @@ int HP_itemdb_chain_item(unsigned short chain_id, int *rate) { void HP_itemdb_package_item(struct map_session_data *sd, struct item_package *package) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_package_item_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_package *package); + void (*preHookFunc) (struct map_session_data **sd, struct item_package **package); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_package_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_package_item_pre[hIndex].func; - preHookFunc(sd, package); + preHookFunc(&sd, &package); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35047,12 +35221,12 @@ int HP_itemdb_searchname_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_searchname_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_itemdb_searchname_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -35066,11 +35240,11 @@ int HP_itemdb_searchname_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_itemdb_searchname_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_itemdb_searchname_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -35099,11 +35273,11 @@ int HP_itemdb_searchname_array_sub(union DBKey key, struct DBData data, va_list va_end(ap___copy); } if( HPMHooks.count.HP_itemdb_searchname_array_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_array_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_itemdb_searchname_array_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, &data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -35113,11 +35287,11 @@ int HP_itemdb_searchrandomid(struct item_group *group) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_searchrandomid_pre ) { - int (*preHookFunc) (struct item_group *group); + int (*preHookFunc) (struct item_group **group); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchrandomid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_searchrandomid_pre[hIndex].func; - retVal___ = preHookFunc(group); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35155,10 +35329,10 @@ const char* HP_itemdb_typename(int type) { retVal___ = HPMHooks.source.itemdb.typename(type); } if( HPMHooks.count.HP_itemdb_typename_post ) { - const char* (*postHookFunc) (const char* retVal___, int *type); + const char* (*postHookFunc) (const char* retVal___, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_typename_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_typename_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -35166,11 +35340,11 @@ const char* HP_itemdb_typename(int type) { void HP_itemdb_jobmask2mapid(uint64 *bclass, uint64 jobmask) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_jobmask2mapid_pre ) { - void (*preHookFunc) (uint64 *bclass, uint64 *jobmask); + void (*preHookFunc) (uint64 **bclass, uint64 *jobmask); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobmask2mapid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_jobmask2mapid_pre[hIndex].func; - preHookFunc(bclass, &jobmask); + preHookFunc(&bclass, &jobmask); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35181,10 +35355,10 @@ void HP_itemdb_jobmask2mapid(uint64 *bclass, uint64 jobmask) { HPMHooks.source.itemdb.jobmask2mapid(bclass, jobmask); } if( HPMHooks.count.HP_itemdb_jobmask2mapid_post ) { - void (*postHookFunc) (uint64 *bclass, uint64 *jobmask); + void (*postHookFunc) (uint64 *bclass, uint64 jobmask); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobmask2mapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_jobmask2mapid_post[hIndex].func; - postHookFunc(bclass, &jobmask); + postHookFunc(bclass, jobmask); } } return; @@ -35192,11 +35366,11 @@ void HP_itemdb_jobmask2mapid(uint64 *bclass, uint64 jobmask) { void HP_itemdb_jobid2mapid(uint64 *bclass, int job_id, bool enable) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_jobid2mapid_pre ) { - void (*preHookFunc) (uint64 *bclass, int *job_id, bool *enable); + void (*preHookFunc) (uint64 **bclass, int *job_id, bool *enable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_pre[hIndex].func; - preHookFunc(bclass, &job_id, &enable); + preHookFunc(&bclass, &job_id, &enable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35207,10 +35381,10 @@ void HP_itemdb_jobid2mapid(uint64 *bclass, int job_id, bool enable) { HPMHooks.source.itemdb.jobid2mapid(bclass, job_id, enable); } if( HPMHooks.count.HP_itemdb_jobid2mapid_post ) { - void (*postHookFunc) (uint64 *bclass, int *job_id, bool *enable); + void (*postHookFunc) (uint64 *bclass, int job_id, bool enable); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_post[hIndex].func; - postHookFunc(bclass, &job_id, &enable); + postHookFunc(bclass, job_id, enable); } } return; @@ -35260,10 +35434,10 @@ struct item_data* HP_itemdb_create_item_data(int nameid) { retVal___ = HPMHooks.source.itemdb.create_item_data(nameid); } if( HPMHooks.count.HP_itemdb_create_item_data_post ) { - struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid); + struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_item_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_create_item_data_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -35287,10 +35461,10 @@ int HP_itemdb_isequip(int nameid) { retVal___ = HPMHooks.source.itemdb.isequip(nameid); } if( HPMHooks.count.HP_itemdb_isequip_post ) { - int (*postHookFunc) (int retVal___, int *nameid); + int (*postHookFunc) (int retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_isequip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -35299,11 +35473,11 @@ int HP_itemdb_isequip2(struct item_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_isequip2_pre ) { - int (*preHookFunc) (struct item_data *data); + int (*preHookFunc) (struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_isequip2_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35341,10 +35515,10 @@ int HP_itemdb_isstackable(int nameid) { retVal___ = HPMHooks.source.itemdb.isstackable(nameid); } if( HPMHooks.count.HP_itemdb_isstackable_post ) { - int (*postHookFunc) (int retVal___, int *nameid); + int (*postHookFunc) (int retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_isstackable_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -35353,11 +35527,11 @@ int HP_itemdb_isstackable2(struct item_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_isstackable2_pre ) { - int (*preHookFunc) (struct item_data *data); + int (*preHookFunc) (struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_isstackable2_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35380,11 +35554,11 @@ int HP_itemdb_isdropable_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_isdropable_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isdropable_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_isdropable_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35395,10 +35569,10 @@ int HP_itemdb_isdropable_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.isdropable_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_isdropable_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isdropable_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_isdropable_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35407,11 +35581,11 @@ int HP_itemdb_cantrade_sub(struct item_data *item, int gmlv, int gmlv2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_cantrade_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *gmlv2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cantrade_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_cantrade_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &gmlv2); + retVal___ = preHookFunc(&item, &gmlv, &gmlv2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35422,10 +35596,10 @@ int HP_itemdb_cantrade_sub(struct item_data *item, int gmlv, int gmlv2) { retVal___ = HPMHooks.source.itemdb.cantrade_sub(item, gmlv, gmlv2); } if( HPMHooks.count.HP_itemdb_cantrade_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *gmlv2); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int gmlv2); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cantrade_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_cantrade_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2); + retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2); } } return retVal___; @@ -35434,11 +35608,11 @@ int HP_itemdb_canpartnertrade_sub(struct item_data *item, int gmlv, int gmlv2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *gmlv2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canpartnertrade_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_canpartnertrade_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &gmlv2); + retVal___ = preHookFunc(&item, &gmlv, &gmlv2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35449,10 +35623,10 @@ int HP_itemdb_canpartnertrade_sub(struct item_data *item, int gmlv, int gmlv2) { retVal___ = HPMHooks.source.itemdb.canpartnertrade_sub(item, gmlv, gmlv2); } if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *gmlv2); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int gmlv2); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canpartnertrade_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_canpartnertrade_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2); + retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2); } } return retVal___; @@ -35461,11 +35635,11 @@ int HP_itemdb_cansell_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_cansell_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cansell_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_cansell_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35476,10 +35650,10 @@ int HP_itemdb_cansell_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.cansell_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_cansell_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cansell_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_cansell_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35488,11 +35662,11 @@ int HP_itemdb_cancartstore_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_cancartstore_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cancartstore_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_cancartstore_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35503,10 +35677,10 @@ int HP_itemdb_cancartstore_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.cancartstore_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_cancartstore_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cancartstore_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_cancartstore_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35515,11 +35689,11 @@ int HP_itemdb_canstore_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_canstore_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canstore_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_canstore_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35530,10 +35704,10 @@ int HP_itemdb_canstore_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.canstore_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_canstore_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canstore_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_canstore_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35542,11 +35716,11 @@ int HP_itemdb_canguildstore_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_canguildstore_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canguildstore_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_canguildstore_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35557,10 +35731,10 @@ int HP_itemdb_canguildstore_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.canguildstore_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_canguildstore_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canguildstore_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_canguildstore_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35569,11 +35743,11 @@ int HP_itemdb_canmail_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_canmail_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canmail_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_canmail_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35584,10 +35758,10 @@ int HP_itemdb_canmail_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.canmail_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_canmail_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canmail_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_canmail_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35596,11 +35770,11 @@ int HP_itemdb_canauction_sub(struct item_data *item, int gmlv, int unused) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_canauction_sub_pre ) { - int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused); + int (*preHookFunc) (struct item_data **item, int *gmlv, int *unused); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canauction_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_canauction_sub_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &unused); + retVal___ = preHookFunc(&item, &gmlv, &unused); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35611,10 +35785,10 @@ int HP_itemdb_canauction_sub(struct item_data *item, int gmlv, int unused) { retVal___ = HPMHooks.source.itemdb.canauction_sub(item, gmlv, unused); } if( HPMHooks.count.HP_itemdb_canauction_sub_post ) { - int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused); + int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canauction_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_canauction_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &unused); + retVal___ = postHookFunc(retVal___, item, gmlv, unused); } } return retVal___; @@ -35623,11 +35797,11 @@ int HP_itemdb_isrestricted(struct item *item, int gmlv, int gmlv2, int ( *func ) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_isrestricted_pre ) { - int (*preHookFunc) (struct item *item, int *gmlv, int *gmlv2, int ( *func ) (struct item_data *, int, int)); + int (*preHookFunc) (struct item **item, int *gmlv, int *gmlv2, int ( **func ) (struct item_data *, int, int)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isrestricted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_isrestricted_pre[hIndex].func; - retVal___ = preHookFunc(item, &gmlv, &gmlv2, func); + retVal___ = preHookFunc(&item, &gmlv, &gmlv2, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35638,10 +35812,10 @@ int HP_itemdb_isrestricted(struct item *item, int gmlv, int gmlv2, int ( *func ) retVal___ = HPMHooks.source.itemdb.isrestricted(item, gmlv, gmlv2, func); } if( HPMHooks.count.HP_itemdb_isrestricted_post ) { - int (*postHookFunc) (int retVal___, struct item *item, int *gmlv, int *gmlv2, int ( *func ) (struct item_data *, int, int)); + int (*postHookFunc) (int retVal___, struct item *item, int gmlv, int gmlv2, int ( *func ) (struct item_data *, int, int)); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isrestricted_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_isrestricted_post[hIndex].func; - retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2, func); + retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2, func); } } return retVal___; @@ -35665,10 +35839,10 @@ int HP_itemdb_isidentified(int nameid) { retVal___ = HPMHooks.source.itemdb.isidentified(nameid); } if( HPMHooks.count.HP_itemdb_isidentified_post ) { - int (*postHookFunc) (int retVal___, int *nameid); + int (*postHookFunc) (int retVal___, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_isidentified_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid); + retVal___ = postHookFunc(retVal___, nameid); } } return retVal___; @@ -35677,11 +35851,11 @@ int HP_itemdb_isidentified2(struct item_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_isidentified2_pre ) { - int (*preHookFunc) (struct item_data *data); + int (*preHookFunc) (struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_isidentified2_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35704,11 +35878,11 @@ int HP_itemdb_combo_split_atoi(char *str, int *val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_combo_split_atoi_pre ) { - int (*preHookFunc) (char *str, int *val); + int (*preHookFunc) (char **str, int **val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_combo_split_atoi_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_combo_split_atoi_pre[hIndex].func; - retVal___ = preHookFunc(str, val); + retVal___ = preHookFunc(&str, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35757,11 +35931,11 @@ int HP_itemdb_gendercheck(struct item_data *id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_gendercheck_pre ) { - int (*preHookFunc) (struct item_data *id); + int (*preHookFunc) (struct item_data **id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_gendercheck_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_gendercheck_pre[hIndex].func; - retVal___ = preHookFunc(id); + retVal___ = preHookFunc(&id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35784,11 +35958,11 @@ int HP_itemdb_validate_entry(struct item_data *entry, int n, const char *source) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_validate_entry_pre ) { - int (*preHookFunc) (struct item_data *entry, int *n, const char *source); + int (*preHookFunc) (struct item_data **entry, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_validate_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_validate_entry_pre[hIndex].func; - retVal___ = preHookFunc(entry, &n, source); + retVal___ = preHookFunc(&entry, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35799,10 +35973,10 @@ int HP_itemdb_validate_entry(struct item_data *entry, int n, const char *source) retVal___ = HPMHooks.source.itemdb.validate_entry(entry, n, source); } if( HPMHooks.count.HP_itemdb_validate_entry_post ) { - int (*postHookFunc) (int retVal___, struct item_data *entry, int *n, const char *source); + int (*postHookFunc) (int retVal___, struct item_data *entry, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_validate_entry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_validate_entry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, entry, &n, source); + retVal___ = postHookFunc(retVal___, entry, n, source); } } return retVal___; @@ -35810,11 +35984,11 @@ int HP_itemdb_validate_entry(struct item_data *entry, int n, const char *source) void HP_itemdb_readdb_additional_fields(int itemid, struct config_setting_t *it, int n, const char *source) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_readdb_additional_fields_pre ) { - void (*preHookFunc) (int *itemid, struct config_setting_t *it, int *n, const char *source); + void (*preHookFunc) (int *itemid, struct config_setting_t **it, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_additional_fields_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_readdb_additional_fields_pre[hIndex].func; - preHookFunc(&itemid, it, &n, source); + preHookFunc(&itemid, &it, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35825,10 +35999,10 @@ void HP_itemdb_readdb_additional_fields(int itemid, struct config_setting_t *it, HPMHooks.source.itemdb.readdb_additional_fields(itemid, it, n, source); } if( HPMHooks.count.HP_itemdb_readdb_additional_fields_post ) { - void (*postHookFunc) (int *itemid, struct config_setting_t *it, int *n, const char *source); + void (*postHookFunc) (int itemid, struct config_setting_t *it, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_additional_fields_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_readdb_additional_fields_post[hIndex].func; - postHookFunc(&itemid, it, &n, source); + postHookFunc(itemid, it, n, source); } } return; @@ -35836,11 +36010,11 @@ void HP_itemdb_readdb_additional_fields(int itemid, struct config_setting_t *it, void HP_itemdb_readdb_job_sub(struct item_data *id, struct config_setting_t *t) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_readdb_job_sub_pre ) { - void (*preHookFunc) (struct item_data *id, struct config_setting_t *t); + void (*preHookFunc) (struct item_data **id, struct config_setting_t **t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_job_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_readdb_job_sub_pre[hIndex].func; - preHookFunc(id, t); + preHookFunc(&id, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35863,11 +36037,11 @@ int HP_itemdb_readdb_libconfig_sub(struct config_setting_t *it, int n, const cha int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_readdb_libconfig_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *it, int *n, const char *source); + int (*preHookFunc) (struct config_setting_t **it, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_sub_pre[hIndex].func; - retVal___ = preHookFunc(it, &n, source); + retVal___ = preHookFunc(&it, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35878,10 +36052,10 @@ int HP_itemdb_readdb_libconfig_sub(struct config_setting_t *it, int n, const cha retVal___ = HPMHooks.source.itemdb.readdb_libconfig_sub(it, n, source); } if( HPMHooks.count.HP_itemdb_readdb_libconfig_sub_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *it, int *n, const char *source); + int (*postHookFunc) (int retVal___, struct config_setting_t *it, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, it, &n, source); + retVal___ = postHookFunc(retVal___, it, n, source); } } return retVal___; @@ -35890,11 +36064,11 @@ int HP_itemdb_readdb_libconfig(const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_readdb_libconfig_pre ) { - int (*preHookFunc) (const char *filename); + int (*preHookFunc) (const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_pre[hIndex].func; - retVal___ = preHookFunc(filename); + retVal___ = preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35917,11 +36091,11 @@ uint64 HP_itemdb_unique_id(struct map_session_data *sd) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_itemdb_unique_id_pre ) { - uint64 (*preHookFunc) (struct map_session_data *sd); + uint64 (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_unique_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_unique_id_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35958,10 +36132,10 @@ void HP_itemdb_read(bool minimal) { HPMHooks.source.itemdb.read(minimal); } if( HPMHooks.count.HP_itemdb_read_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -35969,11 +36143,11 @@ void HP_itemdb_read(bool minimal) { void HP_itemdb_destroy_item_data(struct item_data *self, int free_self) { int hIndex = 0; if( HPMHooks.count.HP_itemdb_destroy_item_data_pre ) { - void (*preHookFunc) (struct item_data *self, int *free_self); + void (*preHookFunc) (struct item_data **self, int *free_self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_destroy_item_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_destroy_item_data_pre[hIndex].func; - preHookFunc(self, &free_self); + preHookFunc(&self, &free_self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -35984,10 +36158,10 @@ void HP_itemdb_destroy_item_data(struct item_data *self, int free_self) { HPMHooks.source.itemdb.destroy_item_data(self, free_self); } if( HPMHooks.count.HP_itemdb_destroy_item_data_post ) { - void (*postHookFunc) (struct item_data *self, int *free_self); + void (*postHookFunc) (struct item_data *self, int free_self); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_destroy_item_data_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_destroy_item_data_post[hIndex].func; - postHookFunc(self, &free_self); + postHookFunc(self, free_self); } } return; @@ -35996,12 +36170,12 @@ int HP_itemdb_final_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_itemdb_final_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_itemdb_final_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -36015,11 +36189,11 @@ int HP_itemdb_final_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_itemdb_final_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_itemdb_final_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -36043,10 +36217,10 @@ void HP_itemdb_clear(bool total) { HPMHooks.source.itemdb.clear(total); } if( HPMHooks.count.HP_itemdb_clear_post ) { - void (*postHookFunc) (bool *total); + void (*postHookFunc) (bool total); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_clear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_clear_post[hIndex].func; - postHookFunc(&total); + postHookFunc(total); } } return; @@ -36070,10 +36244,10 @@ struct item_combo* HP_itemdb_id2combo(unsigned short id) { retVal___ = HPMHooks.source.itemdb.id2combo(id); } if( HPMHooks.count.HP_itemdb_id2combo_post ) { - struct item_combo* (*postHookFunc) (struct item_combo* retVal___, unsigned short *id); + struct item_combo* (*postHookFunc) (struct item_combo* retVal___, unsigned short id); for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_id2combo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_itemdb_id2combo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -36082,11 +36256,11 @@ bool HP_itemdb_is_item_usable(struct item_data *item) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_itemdb_is_item_usable_pre ) { - bool (*preHookFunc) (struct item_data *item); + bool (*preHookFunc) (struct item_data **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_is_item_usable_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_is_item_usable_pre[hIndex].func; - retVal___ = preHookFunc(item); + retVal___ = preHookFunc(&item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36109,11 +36283,11 @@ bool HP_itemdb_lookup_const(const struct config_setting_t *it, const char *name, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_itemdb_lookup_const_pre ) { - bool (*preHookFunc) (const struct config_setting_t *it, const char *name, int *value); + bool (*preHookFunc) (const struct config_setting_t **it, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_lookup_const_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_itemdb_lookup_const_pre[hIndex].func; - retVal___ = preHookFunc(it, name, value); + retVal___ = preHookFunc(&it, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36137,11 +36311,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_pre ) { - int (*preHookFunc) (struct config_t *config, FILE *stream); + int (*preHookFunc) (struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func; - retVal___ = preHookFunc(config, stream); + retVal___ = preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36163,11 +36337,11 @@ int HP_libconfig_read(struct config_t *config, FILE *stream) { void HP_libconfig_write(const struct config_t *config, FILE *stream) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_write_pre ) { - void (*preHookFunc) (const struct config_t *config, FILE *stream); + void (*preHookFunc) (const struct config_t **config, FILE **stream); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func; - preHookFunc(config, stream); + preHookFunc(&config, &stream); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36189,11 +36363,11 @@ void HP_libconfig_write(const struct config_t *config, FILE *stream) { void HP_libconfig_set_options(struct config_t *config, int options) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_options_pre ) { - void (*preHookFunc) (struct config_t *config, int *options); + void (*preHookFunc) (struct config_t **config, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_options_pre[hIndex].func; - preHookFunc(config, &options); + preHookFunc(&config, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36204,10 +36378,10 @@ void HP_libconfig_set_options(struct config_t *config, int options) { HPMHooks.source.libconfig.set_options(config, options); } if( HPMHooks.count.HP_libconfig_set_options_post ) { - void (*postHookFunc) (struct config_t *config, int *options); + void (*postHookFunc) (struct config_t *config, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_set_options_post[hIndex].func; - postHookFunc(config, &options); + postHookFunc(config, options); } } return; @@ -36216,11 +36390,11 @@ int HP_libconfig_get_options(const struct config_t *config) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_get_options_pre ) { - int (*preHookFunc) (const struct config_t *config); + int (*preHookFunc) (const struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_get_options_pre[hIndex].func; - retVal___ = preHookFunc(config); + retVal___ = preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36243,11 +36417,11 @@ int HP_libconfig_read_string(struct config_t *config, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_string_pre ) { - int (*preHookFunc) (struct config_t *config, const char *str); + int (*preHookFunc) (struct config_t **config, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func; - retVal___ = preHookFunc(config, str); + retVal___ = preHookFunc(&config, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36270,11 +36444,11 @@ int HP_libconfig_read_file_src(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_read_file_src_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36297,11 +36471,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_write_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *filename); + int (*preHookFunc) (struct config_t **config, const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func; - retVal___ = preHookFunc(config, filename); + retVal___ = preHookFunc(&config, &filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36323,11 +36497,11 @@ int HP_libconfig_write_file(struct config_t *config, const char *filename) { void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) (void *)) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_destructor_pre ) { - void (*preHookFunc) (struct config_t *config, void ( *destructor ) (void *)); + void (*preHookFunc) (struct config_t **config, void ( **destructor ) (void *)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func; - preHookFunc(config, destructor); + preHookFunc(&config, &destructor); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36349,11 +36523,11 @@ void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) ( void HP_libconfig_set_include_dir(struct config_t *config, const char *include_dir) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) { - void (*preHookFunc) (struct config_t *config, const char *include_dir); + void (*preHookFunc) (struct config_t **config, const char **include_dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func; - preHookFunc(config, include_dir); + preHookFunc(&config, &include_dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36375,11 +36549,11 @@ void HP_libconfig_set_include_dir(struct config_t *config, const char *include_d void HP_libconfig_init(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_init_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36401,11 +36575,11 @@ void HP_libconfig_init(struct config_t *config) { void HP_libconfig_destroy(struct config_t *config) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_destroy_pre ) { - void (*preHookFunc) (struct config_t *config); + void (*preHookFunc) (struct config_t **config); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func; - preHookFunc(config); + preHookFunc(&config); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36428,11 +36602,11 @@ int HP_libconfig_setting_get_int(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36455,11 +36629,11 @@ long long HP_libconfig_setting_get_int64(const struct config_setting_t *setting) int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting); + long long (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36482,11 +36656,11 @@ double HP_libconfig_setting_get_float(const struct config_setting_t *setting) { int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting); + double (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36509,11 +36683,11 @@ int HP_libconfig_setting_get_bool(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36536,11 +36710,11 @@ const char* HP_libconfig_setting_get_string(const struct config_setting_t *setti int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting); + const char* (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36563,11 +36737,11 @@ struct config_setting_t* HP_libconfig_setting_lookup(struct config_setting_t *se int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36590,11 +36764,11 @@ int HP_libconfig_setting_lookup_int(const struct config_setting_t *setting, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36617,11 +36791,11 @@ int HP_libconfig_setting_lookup_int64(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, long long *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36644,11 +36818,11 @@ int HP_libconfig_setting_lookup_float(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, double *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36671,11 +36845,11 @@ int HP_libconfig_setting_lookup_bool(const struct config_setting_t *setting, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36698,11 +36872,11 @@ int HP_libconfig_setting_lookup_string(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, const char **value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36725,11 +36899,11 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36740,10 +36914,10 @@ int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -36752,11 +36926,11 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, long long *value); + int (*preHookFunc) (struct config_setting_t **setting, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36767,10 +36941,10 @@ int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long v retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -36779,11 +36953,11 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, double *value); + int (*preHookFunc) (struct config_setting_t **setting, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36794,10 +36968,10 @@ int HP_libconfig_setting_set_float(struct config_setting_t *setting, double valu retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -36806,11 +36980,11 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, int *value); + int (*preHookFunc) (struct config_setting_t **setting, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func; - retVal___ = preHookFunc(setting, &value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36821,10 +36995,10 @@ int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) { retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int *value); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &value); + retVal___ = postHookFunc(retVal___, setting, value); } } return retVal___; @@ -36833,11 +37007,11 @@ int HP_libconfig_setting_set_string(struct config_setting_t *setting, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, const char *value); + int (*preHookFunc) (struct config_setting_t **setting, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, value); + retVal___ = preHookFunc(&setting, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36860,11 +37034,11 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) { - int (*preHookFunc) (struct config_setting_t *setting, short *format); + int (*preHookFunc) (struct config_setting_t **setting, short *format); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func; - retVal___ = preHookFunc(setting, &format); + retVal___ = preHookFunc(&setting, &format); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36875,10 +37049,10 @@ int HP_libconfig_setting_set_format(struct config_setting_t *setting, short form retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format); } if( HPMHooks.count.HP_libconfig_setting_set_format_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short *format); + int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short format); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &format); + retVal___ = postHookFunc(retVal___, setting, format); } } return retVal___; @@ -36887,11 +37061,11 @@ short HP_libconfig_setting_get_format(const struct config_setting_t *setting) { int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) { - short (*preHookFunc) (const struct config_setting_t *setting); + short (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36914,11 +37088,11 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36929,10 +37103,10 @@ int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, in retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -36941,11 +37115,11 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set int hIndex = 0; long long retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) { - long long (*preHookFunc) (const struct config_setting_t *setting, int *idx); + long long (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36956,10 +37130,10 @@ long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *set retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) { - long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int *idx); + long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -36968,11 +37142,11 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin int hIndex = 0; double retVal___ = 0.; if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) { - double (*preHookFunc) (const struct config_setting_t *setting, int *idx); + double (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -36983,10 +37157,10 @@ double HP_libconfig_setting_get_float_elem(const struct config_setting_t *settin retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) { - double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int *idx); + double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -36995,11 +37169,11 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, int *idx); + int (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37010,10 +37184,10 @@ int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, i retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int *idx); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -37022,11 +37196,11 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) { - const char* (*preHookFunc) (const struct config_setting_t *setting, int *idx); + const char* (*preHookFunc) (const struct config_setting_t **setting, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37037,10 +37211,10 @@ const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t * retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) { - const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int *idx); + const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -37049,11 +37223,11 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37064,10 +37238,10 @@ struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -37076,11 +37250,11 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, long long *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37091,10 +37265,10 @@ struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, long long *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, long long value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -37103,11 +37277,11 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, double *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37118,10 +37292,10 @@ struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setti retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, double *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, double value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -37130,11 +37304,11 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, &value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37145,10 +37319,10 @@ struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_settin retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, int *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, &value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -37157,11 +37331,11 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, const char **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx, value); + retVal___ = preHookFunc(&setting, &idx, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37172,10 +37346,10 @@ struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_sett retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value); } if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int *idx, const char *value); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, const char *value); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx, value); + retVal___ = postHookFunc(retVal___, setting, idx, value); } } return retVal___; @@ -37184,11 +37358,11 @@ int HP_libconfig_setting_index(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_index_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37211,11 +37385,11 @@ int HP_libconfig_setting_length(const struct config_setting_t *setting) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_length_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting); + int (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37238,11 +37412,11 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func; - retVal___ = preHookFunc(setting, &idx); + retVal___ = preHookFunc(&setting, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37253,10 +37427,10 @@ struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setti retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx); } if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int *idx); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, &idx); + retVal___ = postHookFunc(retVal___, setting, idx); } } return retVal___; @@ -37265,11 +37439,11 @@ struct config_setting_t* HP_libconfig_setting_get_member(const struct config_set int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_setting_t *setting, const char *name); + struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func; - retVal___ = preHookFunc(setting, name); + retVal___ = preHookFunc(&setting, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37292,11 +37466,11 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_setting_add_pre ) { - struct config_setting_t* (*preHookFunc) (struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*preHookFunc) (struct config_setting_t **parent, const char **name, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func; - retVal___ = preHookFunc(parent, name, &type); + retVal___ = preHookFunc(&parent, &name, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37307,10 +37481,10 @@ struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *paren retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type); } if( HPMHooks.count.HP_libconfig_setting_add_post ) { - struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int *type); + struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, name, &type); + retVal___ = postHookFunc(retVal___, parent, name, type); } } return retVal___; @@ -37319,11 +37493,11 @@ int HP_libconfig_setting_remove(struct config_setting_t *parent, const char *nam int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const char *name); + int (*preHookFunc) (struct config_setting_t **parent, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func; - retVal___ = preHookFunc(parent, name); + retVal___ = preHookFunc(&parent, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37346,11 +37520,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, unsigned int *idx); + int (*preHookFunc) (struct config_setting_t **parent, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func; - retVal___ = preHookFunc(parent, &idx); + retVal___ = preHookFunc(&parent, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37361,10 +37535,10 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx); } if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int *idx); + int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, parent, &idx); + retVal___ = postHookFunc(retVal___, parent, idx); } } return retVal___; @@ -37372,11 +37546,11 @@ int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned i void HP_libconfig_setting_set_hook(struct config_setting_t *setting, void *hook) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) { - void (*preHookFunc) (struct config_setting_t *setting, void *hook); + void (*preHookFunc) (struct config_setting_t **setting, void **hook); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func; - preHookFunc(setting, hook); + preHookFunc(&setting, &hook); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37399,11 +37573,11 @@ struct config_setting_t* HP_libconfig_lookup(const struct config_t *config, cons int hIndex = 0; struct config_setting_t* retVal___ = NULL; if( HPMHooks.count.HP_libconfig_lookup_pre ) { - struct config_setting_t* (*preHookFunc) (const struct config_t *config, const char *filepath); + struct config_setting_t* (*preHookFunc) (const struct config_t **config, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath); + retVal___ = preHookFunc(&config, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37426,11 +37600,11 @@ int HP_libconfig_lookup_int(const struct config_t *config, const char *filepath, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37453,11 +37627,11 @@ int HP_libconfig_lookup_int64(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, long long *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, long long **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37480,11 +37654,11 @@ int HP_libconfig_lookup_float(const struct config_t *config, const char *filepat int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_float_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, double *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, double **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37507,11 +37681,11 @@ int HP_libconfig_lookup_bool(const struct config_t *config, const char *filepath int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, int *value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37534,11 +37708,11 @@ int HP_libconfig_lookup_string(const struct config_t *config, const char *filepa int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *filepath, const char **value); + int (*preHookFunc) (const struct config_t **config, const char **filepath, const char ***value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func; - retVal___ = preHookFunc(config, filepath, value); + retVal___ = preHookFunc(&config, &filepath, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37561,11 +37735,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_load_file_pre ) { - int (*preHookFunc) (struct config_t *config, const char *config_filename); + int (*preHookFunc) (struct config_t **config, const char **config_filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_load_file_pre[hIndex].func; - retVal___ = preHookFunc(config, config_filename); + retVal___ = preHookFunc(&config, &config_filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37587,11 +37761,11 @@ int HP_libconfig_load_file(struct config_t *config, const char *config_filename) void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37613,11 +37787,11 @@ void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const str void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37639,11 +37813,11 @@ void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struc void HP_libconfig_setting_copy_aggregate(struct config_setting_t *parent, const struct config_setting_t *src) { int hIndex = 0; if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) { - void (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func; - preHookFunc(parent, src); + preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37666,11 +37840,11 @@ int HP_libconfig_setting_copy(struct config_setting_t *parent, const struct conf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_copy_pre ) { - int (*preHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src); + int (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func; - retVal___ = preHookFunc(parent, src); + retVal___ = preHookFunc(&parent, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37693,11 +37867,11 @@ bool HP_libconfig_setting_get_bool_real(const struct config_setting_t *setting) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_libconfig_setting_get_bool_real_pre ) { - bool (*preHookFunc) (const struct config_setting_t *setting); + bool (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37720,11 +37894,11 @@ uint32 HP_libconfig_setting_get_uint32(const struct config_setting_t *setting) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint32_pre ) { - uint32 (*preHookFunc) (const struct config_setting_t *setting); + uint32 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37747,11 +37921,11 @@ uint16 HP_libconfig_setting_get_uint16(const struct config_setting_t *setting) { int hIndex = 0; uint16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_uint16_pre ) { - uint16 (*preHookFunc) (const struct config_setting_t *setting); + uint16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37774,11 +37948,11 @@ int16 HP_libconfig_setting_get_int16(const struct config_setting_t *setting) { int hIndex = 0; int16 retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_get_int16_pre ) { - int16 (*preHookFunc) (const struct config_setting_t *setting); + int16 (*preHookFunc) (const struct config_setting_t **setting); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting); + retVal___ = preHookFunc(&setting); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37801,11 +37975,11 @@ int HP_libconfig_setting_lookup_bool_real(const struct config_setting_t *setting int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, bool *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, bool **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37828,11 +38002,11 @@ int HP_libconfig_setting_lookup_uint32(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint32 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint32 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37855,11 +38029,11 @@ int HP_libconfig_setting_lookup_uint16(const struct config_setting_t *setting, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, uint16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37882,11 +38056,11 @@ int HP_libconfig_setting_lookup_int16(const struct config_setting_t *setting, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_int16_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, int16 *value); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int16 **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, value); + retVal___ = preHookFunc(&setting, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37909,11 +38083,11 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(setting, name, out, &out_size); + retVal___ = preHookFunc(&setting, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37924,10 +38098,10 @@ int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *se retVal___ = HPMHooks.source.libconfig.setting_lookup_mutable_string(setting, name, out, out_size); } if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, setting, name, out, &out_size); + retVal___ = postHookFunc(retVal___, setting, name, out, out_size); } } return retVal___; @@ -37936,11 +38110,11 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libconfig_lookup_mutable_string_pre ) { - int (*preHookFunc) (const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*preHookFunc) (const struct config_t **config, const char **name, char **out, size_t *out_size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_pre[hIndex].func; - retVal___ = preHookFunc(config, name, out, &out_size); + retVal___ = preHookFunc(&config, &name, &out, &out_size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37951,10 +38125,10 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char retVal___ = HPMHooks.source.libconfig.lookup_mutable_string(config, name, out, out_size); } if( HPMHooks.count.HP_libconfig_lookup_mutable_string_post ) { - int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t *out_size); + int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_post[hIndex].func; - retVal___ = postHookFunc(retVal___, config, name, out, &out_size); + retVal___ = postHookFunc(retVal___, config, name, out, out_size); } } return retVal___; @@ -37963,11 +38137,11 @@ int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) { int hIndex = 0; if( HPMHooks.count.HP_logs_pick_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_pick_pc_pre[hIndex].func; - preHookFunc(sd, &type, &amount, itm, data); + preHookFunc(&sd, &type, &amount, &itm, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -37978,10 +38152,10 @@ void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amou HPMHooks.source.logs.pick_pc(sd, type, amount, itm, data); } if( HPMHooks.count.HP_logs_pick_pc_post ) { - void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_pc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_pick_pc_post[hIndex].func; - postHookFunc(sd, &type, &amount, itm, data); + postHookFunc(sd, type, amount, itm, data); } } return; @@ -37989,11 +38163,11 @@ void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amou void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) { int hIndex = 0; if( HPMHooks.count.HP_logs_pick_mob_pre ) { - void (*preHookFunc) (struct mob_data *md, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*preHookFunc) (struct mob_data **md, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_mob_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_pick_mob_pre[hIndex].func; - preHookFunc(md, &type, &amount, itm, data); + preHookFunc(&md, &type, &amount, &itm, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38004,10 +38178,10 @@ void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, str HPMHooks.source.logs.pick_mob(md, type, amount, itm, data); } if( HPMHooks.count.HP_logs_pick_mob_post ) { - void (*postHookFunc) (struct mob_data *md, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*postHookFunc) (struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_mob_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_pick_mob_post[hIndex].func; - postHookFunc(md, &type, &amount, itm, data); + postHookFunc(md, type, amount, itm, data); } } return; @@ -38015,11 +38189,11 @@ void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, str void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) { int hIndex = 0; if( HPMHooks.count.HP_logs_zeny_pre ) { - void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount); + void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_zeny_pre[hIndex].func; - preHookFunc(sd, &type, src_sd, &amount); + preHookFunc(&sd, &type, &src_sd, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38030,10 +38204,10 @@ void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_ HPMHooks.source.logs.zeny(sd, type, src_sd, amount); } if( HPMHooks.count.HP_logs_zeny_post ) { - void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount); + void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_zeny_post[hIndex].func; - postHookFunc(sd, &type, src_sd, &amount); + postHookFunc(sd, type, src_sd, amount); } } return; @@ -38041,11 +38215,11 @@ void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_ void HP_logs_npc(struct map_session_data *sd, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_npc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *message); + void (*preHookFunc) (struct map_session_data **sd, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_npc_pre[hIndex].func; - preHookFunc(sd, message); + preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38067,11 +38241,11 @@ void HP_logs_npc(struct map_session_data *sd, const char *message) { void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_chat_pre ) { - void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message); + void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_chat_pre[hIndex].func; - preHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message); + preHookFunc(&type, &type_id, &src_charid, &src_accid, &mapname, &x, &y, &dst_charname, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38082,10 +38256,10 @@ void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_acc HPMHooks.source.logs.chat(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message); } if( HPMHooks.count.HP_logs_chat_post ) { - void (*postHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message); + void (*postHookFunc) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_chat_post[hIndex].func; - postHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message); + postHookFunc(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message); } } return; @@ -38093,11 +38267,11 @@ void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_acc void HP_logs_atcommand(struct map_session_data *sd, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_atcommand_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *message); + void (*preHookFunc) (struct map_session_data **sd, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_atcommand_pre[hIndex].func; - preHookFunc(sd, message); + preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38119,11 +38293,11 @@ void HP_logs_atcommand(struct map_session_data *sd, const char *message) { void HP_logs_branch(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_logs_branch_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_branch_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38145,11 +38319,11 @@ void HP_logs_branch(struct map_session_data *sd) { void HP_logs_mvpdrop(struct map_session_data *sd, int monster_id, int *log_mvp) { int hIndex = 0; if( HPMHooks.count.HP_logs_mvpdrop_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp); + void (*preHookFunc) (struct map_session_data **sd, int *monster_id, int **log_mvp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_mvpdrop_pre[hIndex].func; - preHookFunc(sd, &monster_id, log_mvp); + preHookFunc(&sd, &monster_id, &log_mvp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38160,10 +38334,10 @@ void HP_logs_mvpdrop(struct map_session_data *sd, int monster_id, int *log_mvp) HPMHooks.source.logs.mvpdrop(sd, monster_id, log_mvp); } if( HPMHooks.count.HP_logs_mvpdrop_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp); + void (*postHookFunc) (struct map_session_data *sd, int monster_id, int *log_mvp); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_mvpdrop_post[hIndex].func; - postHookFunc(sd, &monster_id, log_mvp); + postHookFunc(sd, monster_id, log_mvp); } } return; @@ -38171,11 +38345,11 @@ void HP_logs_mvpdrop(struct map_session_data *sd, int monster_id, int *log_mvp) void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) { int hIndex = 0; if( HPMHooks.count.HP_logs_pick_sub_pre ) { - void (*preHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*preHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_pick_sub_pre[hIndex].func; - preHookFunc(&id, &m, &type, &amount, itm, data); + preHookFunc(&id, &m, &type, &amount, &itm, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38186,10 +38360,10 @@ void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct HPMHooks.source.logs.pick_sub(id, m, type, amount, itm, data); } if( HPMHooks.count.HP_logs_pick_sub_post ) { - void (*postHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data); + void (*postHookFunc) (int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_pick_sub_post[hIndex].func; - postHookFunc(&id, &m, &type, &amount, itm, data); + postHookFunc(id, m, type, amount, itm, data); } } return; @@ -38197,11 +38371,11 @@ void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) { int hIndex = 0; if( HPMHooks.count.HP_logs_zeny_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount); + void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_zeny_sub_pre[hIndex].func; - preHookFunc(sd, &type, src_sd, &amount); + preHookFunc(&sd, &type, &src_sd, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38212,10 +38386,10 @@ void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct HPMHooks.source.logs.zeny_sub(sd, type, src_sd, amount); } if( HPMHooks.count.HP_logs_zeny_sub_post ) { - void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount); + void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_zeny_sub_post[hIndex].func; - postHookFunc(sd, &type, src_sd, &amount); + postHookFunc(sd, type, src_sd, amount); } } return; @@ -38223,11 +38397,11 @@ void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct void HP_logs_npc_sub(struct map_session_data *sd, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_npc_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *message); + void (*preHookFunc) (struct map_session_data **sd, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_npc_sub_pre[hIndex].func; - preHookFunc(sd, message); + preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38249,11 +38423,11 @@ void HP_logs_npc_sub(struct map_session_data *sd, const char *message) { void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_chat_sub_pre ) { - void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message); + void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_chat_sub_pre[hIndex].func; - preHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message); + preHookFunc(&type, &type_id, &src_charid, &src_accid, &mapname, &x, &y, &dst_charname, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38264,10 +38438,10 @@ void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src HPMHooks.source.logs.chat_sub(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message); } if( HPMHooks.count.HP_logs_chat_sub_post ) { - void (*postHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message); + void (*postHookFunc) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_chat_sub_post[hIndex].func; - postHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message); + postHookFunc(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message); } } return; @@ -38275,11 +38449,11 @@ void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src void HP_logs_atcommand_sub(struct map_session_data *sd, const char *message) { int hIndex = 0; if( HPMHooks.count.HP_logs_atcommand_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *message); + void (*preHookFunc) (struct map_session_data **sd, const char **message); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_atcommand_sub_pre[hIndex].func; - preHookFunc(sd, message); + preHookFunc(&sd, &message); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38301,11 +38475,11 @@ void HP_logs_atcommand_sub(struct map_session_data *sd, const char *message) { void HP_logs_branch_sub(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_logs_branch_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_branch_sub_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38327,11 +38501,11 @@ void HP_logs_branch_sub(struct map_session_data *sd) { void HP_logs_mvpdrop_sub(struct map_session_data *sd, int monster_id, int *log_mvp) { int hIndex = 0; if( HPMHooks.count.HP_logs_mvpdrop_sub_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp); + void (*preHookFunc) (struct map_session_data **sd, int *monster_id, int **log_mvp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_mvpdrop_sub_pre[hIndex].func; - preHookFunc(sd, &monster_id, log_mvp); + preHookFunc(&sd, &monster_id, &log_mvp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38342,10 +38516,10 @@ void HP_logs_mvpdrop_sub(struct map_session_data *sd, int monster_id, int *log_m HPMHooks.source.logs.mvpdrop_sub(sd, monster_id, log_mvp); } if( HPMHooks.count.HP_logs_mvpdrop_sub_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp); + void (*postHookFunc) (struct map_session_data *sd, int monster_id, int *log_mvp); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_mvpdrop_sub_post[hIndex].func; - postHookFunc(sd, &monster_id, log_mvp); + postHookFunc(sd, monster_id, log_mvp); } } return; @@ -38354,11 +38528,11 @@ int HP_logs_config_read(const char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_logs_config_read_pre ) { - int (*preHookFunc) (const char *cfgName); + int (*preHookFunc) (const char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38474,10 +38648,10 @@ char HP_logs_picktype2char(e_log_pick_type type) { retVal___ = HPMHooks.source.logs.picktype2char(type); } if( HPMHooks.count.HP_logs_picktype2char_post ) { - char (*postHookFunc) (char retVal___, e_log_pick_type *type); + char (*postHookFunc) (char retVal___, e_log_pick_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_picktype2char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_picktype2char_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -38501,10 +38675,10 @@ char HP_logs_chattype2char(e_log_chat_type type) { retVal___ = HPMHooks.source.logs.chattype2char(type); } if( HPMHooks.count.HP_logs_chattype2char_post ) { - char (*postHookFunc) (char retVal___, e_log_chat_type *type); + char (*postHookFunc) (char retVal___, e_log_chat_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chattype2char_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_chattype2char_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -38513,11 +38687,11 @@ bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_dat int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_logs_should_log_item_pre ) { - bool (*preHookFunc) (int *nameid, int *amount, int *refine, struct item_data *id); + bool (*preHookFunc) (int *nameid, int *amount, int *refine, struct item_data **id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_should_log_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_logs_should_log_item_pre[hIndex].func; - retVal___ = preHookFunc(&nameid, &amount, &refine, id); + retVal___ = preHookFunc(&nameid, &amount, &refine, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38528,10 +38702,10 @@ bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_dat retVal___ = HPMHooks.source.logs.should_log_item(nameid, amount, refine, id); } if( HPMHooks.count.HP_logs_should_log_item_post ) { - bool (*postHookFunc) (bool retVal___, int *nameid, int *amount, int *refine, struct item_data *id); + bool (*postHookFunc) (bool retVal___, int nameid, int amount, int refine, struct item_data *id); for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_should_log_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_logs_should_log_item_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid, &amount, &refine, id); + retVal___ = postHookFunc(retVal___, nameid, amount, refine, id); } } return retVal___; @@ -38540,11 +38714,11 @@ bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_dat void HP_mail_clear(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_mail_clear_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_clear_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38567,11 +38741,11 @@ int HP_mail_removeitem(struct map_session_data *sd, short flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mail_removeitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, short *flag); + int (*preHookFunc) (struct map_session_data **sd, short *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_removeitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38582,10 +38756,10 @@ int HP_mail_removeitem(struct map_session_data *sd, short flag) { retVal___ = HPMHooks.source.mail.removeitem(sd, flag); } if( HPMHooks.count.HP_mail_removeitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, short flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mail_removeitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -38594,11 +38768,11 @@ int HP_mail_removezeny(struct map_session_data *sd, short flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mail_removezeny_pre ) { - int (*preHookFunc) (struct map_session_data *sd, short *flag); + int (*preHookFunc) (struct map_session_data **sd, short *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_removezeny_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38609,10 +38783,10 @@ int HP_mail_removezeny(struct map_session_data *sd, short flag) { retVal___ = HPMHooks.source.mail.removezeny(sd, flag); } if( HPMHooks.count.HP_mail_removezeny_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, short flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mail_removezeny_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -38621,11 +38795,11 @@ unsigned char HP_mail_setitem(struct map_session_data *sd, int idx, int amount) int hIndex = 0; unsigned char retVal___ = 0; if( HPMHooks.count.HP_mail_setitem_pre ) { - unsigned char (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount); + unsigned char (*preHookFunc) (struct map_session_data **sd, int *idx, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_setitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx, &amount); + retVal___ = preHookFunc(&sd, &idx, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38636,10 +38810,10 @@ unsigned char HP_mail_setitem(struct map_session_data *sd, int idx, int amount) retVal___ = HPMHooks.source.mail.setitem(sd, idx, amount); } if( HPMHooks.count.HP_mail_setitem_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, int *idx, int *amount); + unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, int idx, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mail_setitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx, &amount); + retVal___ = postHookFunc(retVal___, sd, idx, amount); } } return retVal___; @@ -38648,11 +38822,11 @@ bool HP_mail_setattachment(struct map_session_data *sd, struct mail_message *msg int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mail_setattachment_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct mail_message *msg); + bool (*preHookFunc) (struct map_session_data **sd, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setattachment_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_setattachment_pre[hIndex].func; - retVal___ = preHookFunc(sd, msg); + retVal___ = preHookFunc(&sd, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38674,11 +38848,11 @@ bool HP_mail_setattachment(struct map_session_data *sd, struct mail_message *msg void HP_mail_getattachment(struct map_session_data *sd, int zeny, struct item *item) { int hIndex = 0; if( HPMHooks.count.HP_mail_getattachment_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *zeny, struct item *item); + void (*preHookFunc) (struct map_session_data **sd, int *zeny, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_getattachment_pre[hIndex].func; - preHookFunc(sd, &zeny, item); + preHookFunc(&sd, &zeny, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38689,10 +38863,10 @@ void HP_mail_getattachment(struct map_session_data *sd, int zeny, struct item *i HPMHooks.source.mail.getattachment(sd, zeny, item); } if( HPMHooks.count.HP_mail_getattachment_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *zeny, struct item *item); + void (*postHookFunc) (struct map_session_data *sd, int zeny, struct item *item); for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mail_getattachment_post[hIndex].func; - postHookFunc(sd, &zeny, item); + postHookFunc(sd, zeny, item); } } return; @@ -38701,11 +38875,11 @@ int HP_mail_openmail(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mail_openmail_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_openmail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_openmail_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38727,11 +38901,11 @@ int HP_mail_openmail(struct map_session_data *sd) { void HP_mail_deliveryfail(struct map_session_data *sd, struct mail_message *msg) { int hIndex = 0; if( HPMHooks.count.HP_mail_deliveryfail_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct mail_message *msg); + void (*preHookFunc) (struct map_session_data **sd, struct mail_message **msg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_deliveryfail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_deliveryfail_pre[hIndex].func; - preHookFunc(sd, msg); + preHookFunc(&sd, &msg); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38754,11 +38928,11 @@ bool HP_mail_invalid_operation(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mail_invalid_operation_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_invalid_operation_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mail_invalid_operation_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38834,11 +39008,11 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_malloc_pre ) { - void* (*preHookFunc) (size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func; - retVal___ = preHookFunc(&size, file, &line, func); + retVal___ = preHookFunc(&size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38849,10 +39023,10 @@ void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *fun retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func); } if( HPMHooks.count.HP_iMalloc_malloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, size, file, line, func); } } return retVal___; @@ -38861,11 +39035,11 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_calloc_pre ) { - void* (*preHookFunc) (size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (size_t *num, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func; - retVal___ = preHookFunc(&num, &size, file, &line, func); + retVal___ = preHookFunc(&num, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38876,10 +39050,10 @@ void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, con retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_calloc_post ) { - void* (*postHookFunc) (void* retVal___, size_t *num, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &num, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, num, size, file, line, func); } } return retVal___; @@ -38888,11 +39062,11 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_realloc_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38903,10 +39077,10 @@ void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_realloc_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -38915,11 +39089,11 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons int hIndex = 0; void* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_reallocz_pre ) { - void* (*preHookFunc) (void *p, size_t *size, const char *file, int *line, const char *func); + void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38930,10 +39104,10 @@ void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, cons retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_reallocz_post ) { - void* (*postHookFunc) (void* retVal___, void *p, size_t *size, const char *file, int *line, const char *func); + void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -38942,11 +39116,11 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrdup_pre ) { - char* (*preHookFunc) (const char *p, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func; - retVal___ = preHookFunc(p, file, &line, func); + retVal___ = preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38957,10 +39131,10 @@ char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char * retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrdup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, file, &line, func); + retVal___ = postHookFunc(retVal___, p, file, line, func); } } return retVal___; @@ -38969,11 +39143,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_iMalloc_astrndup_pre ) { - char* (*preHookFunc) (const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func; - retVal___ = preHookFunc(p, &size, file, &line, func); + retVal___ = preHookFunc(&p, &size, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -38984,10 +39158,10 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line retVal___ = HPMHooks.source.iMalloc.astrndup(p, size, file, line, func); } if( HPMHooks.count.HP_iMalloc_astrndup_post ) { - char* (*postHookFunc) (char* retVal___, const char *p, size_t *size, const char *file, int *line, const char *func); + char* (*postHookFunc) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_astrndup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &size, file, &line, func); + retVal___ = postHookFunc(retVal___, p, size, file, line, func); } } return retVal___; @@ -38995,11 +39169,11 @@ char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { int hIndex = 0; if( HPMHooks.count.HP_iMalloc_free_pre ) { - void (*preHookFunc) (void *p, const char *file, int *line, const char *func); + void (*preHookFunc) (void **p, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func; - preHookFunc(p, file, &line, func); + preHookFunc(&p, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39010,10 +39184,10 @@ void HP_iMalloc_free(void *p, const char *file, int line, const char *func) { HPMHooks.source.iMalloc.free(p, file, line, func); } if( HPMHooks.count.HP_iMalloc_free_post ) { - void (*postHookFunc) (void *p, const char *file, int *line, const char *func); + void (*postHookFunc) (void *p, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func; - postHookFunc(p, file, &line, func); + postHookFunc(p, file, line, func); } } return; @@ -39048,11 +39222,11 @@ bool HP_iMalloc_verify_ptr(void *ptr) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) { - bool (*preHookFunc) (void *ptr); + bool (*preHookFunc) (void **ptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func; - retVal___ = preHookFunc(ptr); + retVal___ = preHookFunc(&ptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39195,10 +39369,10 @@ void HP_map_zone_remove(int m) { HPMHooks.source.map.zone_remove(m); } if( HPMHooks.count.HP_map_zone_remove_post ) { - void (*postHookFunc) (int *m); + void (*postHookFunc) (int m); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_zone_remove_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -39206,11 +39380,11 @@ void HP_map_zone_remove(int m) { void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) { int hIndex = 0; if( HPMHooks.count.HP_map_zone_apply_pre ) { - void (*preHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); + void (*preHookFunc) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_apply_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_apply_pre[hIndex].func; - preHookFunc(&m, zone, start, buffer, filepath); + preHookFunc(&m, &zone, &start, &buffer, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39221,10 +39395,10 @@ void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, con HPMHooks.source.map.zone_apply(m, zone, start, buffer, filepath); } if( HPMHooks.count.HP_map_zone_apply_post ) { - void (*postHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); + void (*postHookFunc) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_apply_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_zone_apply_post[hIndex].func; - postHookFunc(&m, zone, start, buffer, filepath); + postHookFunc(m, zone, start, buffer, filepath); } } return; @@ -39232,11 +39406,11 @@ void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, con void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) { int hIndex = 0; if( HPMHooks.count.HP_map_zone_change_pre ) { - void (*preHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); + void (*preHookFunc) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_change_pre[hIndex].func; - preHookFunc(&m, zone, start, buffer, filepath); + preHookFunc(&m, &zone, &start, &buffer, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39247,10 +39421,10 @@ void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, co HPMHooks.source.map.zone_change(m, zone, start, buffer, filepath); } if( HPMHooks.count.HP_map_zone_change_post ) { - void (*postHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); + void (*postHookFunc) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_zone_change_post[hIndex].func; - postHookFunc(&m, zone, start, buffer, filepath); + postHookFunc(m, zone, start, buffer, filepath); } } return; @@ -39258,11 +39432,11 @@ void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, co void HP_map_zone_change2(int m, struct map_zone_data *zone) { int hIndex = 0; if( HPMHooks.count.HP_map_zone_change2_pre ) { - void (*preHookFunc) (int *m, struct map_zone_data *zone); + void (*preHookFunc) (int *m, struct map_zone_data **zone); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_change2_pre[hIndex].func; - preHookFunc(&m, zone); + preHookFunc(&m, &zone); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39273,10 +39447,10 @@ void HP_map_zone_change2(int m, struct map_zone_data *zone) { HPMHooks.source.map.zone_change2(m, zone); } if( HPMHooks.count.HP_map_zone_change2_post ) { - void (*postHookFunc) (int *m, struct map_zone_data *zone); + void (*postHookFunc) (int m, struct map_zone_data *zone); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_zone_change2_post[hIndex].func; - postHookFunc(&m, zone); + postHookFunc(m, zone); } } return; @@ -39285,11 +39459,11 @@ int HP_map_getcell(int16 m, const struct block_list *bl, int16 x, int16 y, cell_ int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_getcell_pre ) { - int (*preHookFunc) (int16 *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*preHookFunc) (int16 *m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_getcell_pre[hIndex].func; - retVal___ = preHookFunc(&m, bl, &x, &y, &cellchk); + retVal___ = preHookFunc(&m, &bl, &x, &y, &cellchk); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39300,10 +39474,10 @@ int HP_map_getcell(int16 m, const struct block_list *bl, int16 x, int16 y, cell_ retVal___ = HPMHooks.source.map.getcell(m, bl, x, y, cellchk); } if( HPMHooks.count.HP_map_getcell_post ) { - int (*postHookFunc) (int retVal___, int16 *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*postHookFunc) (int retVal___, int16 m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_getcell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, bl, &x, &y, &cellchk); + retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk); } } return retVal___; @@ -39326,10 +39500,10 @@ void HP_map_setgatcell(int16 m, int16 x, int16 y, int gat) { HPMHooks.source.map.setgatcell(m, x, y, gat); } if( HPMHooks.count.HP_map_setgatcell_post ) { - void (*postHookFunc) (int16 *m, int16 *x, int16 *y, int *gat); + void (*postHookFunc) (int16 m, int16 x, int16 y, int gat); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setgatcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_setgatcell_post[hIndex].func; - postHookFunc(&m, &x, &y, &gat); + postHookFunc(m, x, y, gat); } } return; @@ -39337,11 +39511,11 @@ void HP_map_setgatcell(int16 m, int16 x, int16 y, int gat) { void HP_map_cellfromcache(struct map_data *m) { int hIndex = 0; if( HPMHooks.count.HP_map_cellfromcache_pre ) { - void (*preHookFunc) (struct map_data *m); + void (*preHookFunc) (struct map_data **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cellfromcache_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_cellfromcache_pre[hIndex].func; - preHookFunc(m); + preHookFunc(&m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39378,10 +39552,10 @@ void HP_map_setusers(int p1) { HPMHooks.source.map.setusers(p1); } if( HPMHooks.count.HP_map_setusers_post ) { - void (*postHookFunc) (int *p1); + void (*postHookFunc) (int p1); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setusers_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_setusers_post[hIndex].func; - postHookFunc(&p1); + postHookFunc(p1); } } return; @@ -39444,11 +39618,11 @@ int HP_map_freeblock(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_freeblock_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_freeblock_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39525,11 +39699,11 @@ int HP_map_addblock(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_addblock_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addblock_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39552,11 +39726,11 @@ int HP_map_delblock(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_delblock_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_delblock_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39579,11 +39753,11 @@ int HP_map_moveblock(struct block_list *bl, int x1, int y1, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_moveblock_pre ) { - int (*preHookFunc) (struct block_list *bl, int *x1, int *y1, int64 *tick); + int (*preHookFunc) (struct block_list **bl, int *x1, int *y1, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_moveblock_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_moveblock_pre[hIndex].func; - retVal___ = preHookFunc(bl, &x1, &y1, &tick); + retVal___ = preHookFunc(&bl, &x1, &y1, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39594,10 +39768,10 @@ int HP_map_moveblock(struct block_list *bl, int x1, int y1, int64 tick) { retVal___ = HPMHooks.source.map.moveblock(bl, x1, y1, tick); } if( HPMHooks.count.HP_map_moveblock_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *x1, int *y1, int64 *tick); + int (*postHookFunc) (int retVal___, struct block_list *bl, int x1, int y1, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_moveblock_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_moveblock_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &x1, &y1, &tick); + retVal___ = postHookFunc(retVal___, bl, x1, y1, tick); } } return retVal___; @@ -39621,10 +39795,10 @@ int HP_map_count_oncell(int16 m, int16 x, int16 y, int type, int flag) { retVal___ = HPMHooks.source.map.count_oncell(m, x, y, type, flag); } if( HPMHooks.count.HP_map_count_oncell_post ) { - int (*postHookFunc) (int retVal___, int16 *m, int16 *x, int16 *y, int *type, int *flag); + int (*postHookFunc) (int retVal___, int16 m, int16 x, int16 y, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_oncell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_count_oncell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, &x, &y, &type, &flag); + retVal___ = postHookFunc(retVal___, m, x, y, type, flag); } } return retVal___; @@ -39633,11 +39807,11 @@ struct skill_unit* HP_map_find_skill_unit_oncell(struct block_list *target, int1 int hIndex = 0; struct skill_unit* retVal___ = NULL; if( HPMHooks.count.HP_map_find_skill_unit_oncell_pre ) { - struct skill_unit* (*preHookFunc) (struct block_list *target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit *out_unit, int *flag); + struct skill_unit* (*preHookFunc) (struct block_list **target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit **out_unit, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_find_skill_unit_oncell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_find_skill_unit_oncell_pre[hIndex].func; - retVal___ = preHookFunc(target, &x, &y, &skill_id, out_unit, &flag); + retVal___ = preHookFunc(&target, &x, &y, &skill_id, &out_unit, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39648,10 +39822,10 @@ struct skill_unit* HP_map_find_skill_unit_oncell(struct block_list *target, int1 retVal___ = HPMHooks.source.map.find_skill_unit_oncell(target, x, y, skill_id, out_unit, flag); } if( HPMHooks.count.HP_map_find_skill_unit_oncell_post ) { - struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct block_list *target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit *out_unit, int *flag); + struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct block_list *target, int16 x, int16 y, uint16 skill_id, struct skill_unit *out_unit, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_find_skill_unit_oncell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_find_skill_unit_oncell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, target, &x, &y, &skill_id, out_unit, &flag); + retVal___ = postHookFunc(retVal___, target, x, y, skill_id, out_unit, flag); } } return retVal___; @@ -39687,11 +39861,11 @@ int HP_map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_search_freecell_pre ) { - int (*preHookFunc) (struct block_list *src, int16 *m, int16 *x, int16 *y, int16 *rx, int16 *ry, int *flag); + int (*preHookFunc) (struct block_list **src, int16 *m, int16 **x, int16 **y, int16 *rx, int16 *ry, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_search_freecell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_search_freecell_pre[hIndex].func; - retVal___ = preHookFunc(src, &m, x, y, &rx, &ry, &flag); + retVal___ = preHookFunc(&src, &m, &x, &y, &rx, &ry, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39702,10 +39876,10 @@ int HP_map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y, retVal___ = HPMHooks.source.map.search_freecell(src, m, x, y, rx, ry, flag); } if( HPMHooks.count.HP_map_search_freecell_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int16 *m, int16 *x, int16 *y, int16 *rx, int16 *ry, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_search_freecell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_search_freecell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &m, x, y, &rx, &ry, &flag); + retVal___ = postHookFunc(retVal___, src, m, x, y, rx, ry, flag); } } return retVal___; @@ -39714,11 +39888,11 @@ bool HP_map_closest_freecell(int16 m, const struct block_list *bl, int16 *x, int int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_map_closest_freecell_pre ) { - bool (*preHookFunc) (int16 *m, const struct block_list *bl, int16 *x, int16 *y, int *type, int *flag); + bool (*preHookFunc) (int16 *m, const struct block_list **bl, int16 **x, int16 **y, int *type, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_closest_freecell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_closest_freecell_pre[hIndex].func; - retVal___ = preHookFunc(&m, bl, x, y, &type, &flag); + retVal___ = preHookFunc(&m, &bl, &x, &y, &type, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39729,10 +39903,10 @@ bool HP_map_closest_freecell(int16 m, const struct block_list *bl, int16 *x, int retVal___ = HPMHooks.source.map.closest_freecell(m, bl, x, y, type, flag); } if( HPMHooks.count.HP_map_closest_freecell_post ) { - bool (*postHookFunc) (bool retVal___, int16 *m, const struct block_list *bl, int16 *x, int16 *y, int *type, int *flag); + bool (*postHookFunc) (bool retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_closest_freecell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_closest_freecell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, bl, x, y, &type, &flag); + retVal___ = postHookFunc(retVal___, m, bl, x, y, type, flag); } } return retVal___; @@ -39741,11 +39915,11 @@ int HP_map_quit(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_quit_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_quit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_quit_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39768,11 +39942,11 @@ bool HP_map_addnpc(int16 m, struct npc_data *nd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_map_addnpc_pre ) { - bool (*preHookFunc) (int16 *m, struct npc_data *nd); + bool (*preHookFunc) (int16 *m, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addnpc_pre[hIndex].func; - retVal___ = preHookFunc(&m, nd); + retVal___ = preHookFunc(&m, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39783,10 +39957,10 @@ bool HP_map_addnpc(int16 m, struct npc_data *nd) { retVal___ = HPMHooks.source.map.addnpc(m, nd); } if( HPMHooks.count.HP_map_addnpc_post ) { - bool (*postHookFunc) (bool retVal___, int16 *m, struct npc_data *nd); + bool (*postHookFunc) (bool retVal___, int16 m, struct npc_data *nd); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_addnpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, nd); + retVal___ = postHookFunc(retVal___, m, nd); } } return retVal___; @@ -39810,10 +39984,10 @@ int HP_map_clearflooritem_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.map.clearflooritem_timer(tid, tick, id, data); } if( HPMHooks.count.HP_map_clearflooritem_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_clearflooritem_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -39837,10 +40011,10 @@ int HP_map_removemobs_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.map.removemobs_timer(tid, tick, id, data); } if( HPMHooks.count.HP_map_removemobs_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_removemobs_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -39848,11 +40022,11 @@ int HP_map_removemobs_timer(int tid, int64 tick, int id, intptr_t data) { void HP_map_clearflooritem(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_map_clearflooritem_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_clearflooritem_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39875,11 +40049,11 @@ int HP_map_addflooritem(const struct block_list *bl, struct item *item_data, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_addflooritem_pre ) { - int (*preHookFunc) (const struct block_list *bl, struct item *item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags); + int (*preHookFunc) (const struct block_list **bl, struct item **item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addflooritem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addflooritem_pre[hIndex].func; - retVal___ = preHookFunc(bl, item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags); + retVal___ = preHookFunc(&bl, &item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39890,10 +40064,10 @@ int HP_map_addflooritem(const struct block_list *bl, struct item *item_data, int retVal___ = HPMHooks.source.map.addflooritem(bl, item_data, amount, m, x, y, first_charid, second_charid, third_charid, flags); } if( HPMHooks.count.HP_map_addflooritem_post ) { - int (*postHookFunc) (int retVal___, const struct block_list *bl, struct item *item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags); + int (*postHookFunc) (int retVal___, const struct block_list *bl, struct item *item_data, int amount, int16 m, int16 x, int16 y, int first_charid, int second_charid, int third_charid, int flags); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addflooritem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_addflooritem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags); + retVal___ = postHookFunc(retVal___, bl, item_data, amount, m, x, y, first_charid, second_charid, third_charid, flags); } } return retVal___; @@ -39901,11 +40075,11 @@ int HP_map_addflooritem(const struct block_list *bl, struct item *item_data, int void HP_map_addnickdb(int charid, const char *nick) { int hIndex = 0; if( HPMHooks.count.HP_map_addnickdb_pre ) { - void (*preHookFunc) (int *charid, const char *nick); + void (*preHookFunc) (int *charid, const char **nick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addnickdb_pre[hIndex].func; - preHookFunc(&charid, nick); + preHookFunc(&charid, &nick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39916,10 +40090,10 @@ void HP_map_addnickdb(int charid, const char *nick) { HPMHooks.source.map.addnickdb(charid, nick); } if( HPMHooks.count.HP_map_addnickdb_post ) { - void (*postHookFunc) (int *charid, const char *nick); + void (*postHookFunc) (int charid, const char *nick); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_addnickdb_post[hIndex].func; - postHookFunc(&charid, nick); + postHookFunc(charid, nick); } } return; @@ -39927,11 +40101,11 @@ void HP_map_addnickdb(int charid, const char *nick) { void HP_map_delnickdb(int charid, const char *nick) { int hIndex = 0; if( HPMHooks.count.HP_map_delnickdb_pre ) { - void (*preHookFunc) (int *charid, const char *nick); + void (*preHookFunc) (int *charid, const char **nick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_delnickdb_pre[hIndex].func; - preHookFunc(&charid, nick); + preHookFunc(&charid, &nick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39942,10 +40116,10 @@ void HP_map_delnickdb(int charid, const char *nick) { HPMHooks.source.map.delnickdb(charid, nick); } if( HPMHooks.count.HP_map_delnickdb_post ) { - void (*postHookFunc) (int *charid, const char *nick); + void (*postHookFunc) (int charid, const char *nick); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_delnickdb_post[hIndex].func; - postHookFunc(&charid, nick); + postHookFunc(charid, nick); } } return; @@ -39953,11 +40127,11 @@ void HP_map_delnickdb(int charid, const char *nick) { void HP_map_reqnickdb(struct map_session_data *sd, int charid) { int hIndex = 0; if( HPMHooks.count.HP_map_reqnickdb_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *charid); + void (*preHookFunc) (struct map_session_data **sd, int *charid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_reqnickdb_pre[hIndex].func; - preHookFunc(sd, &charid); + preHookFunc(&sd, &charid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -39968,10 +40142,10 @@ void HP_map_reqnickdb(struct map_session_data *sd, int charid) { HPMHooks.source.map.reqnickdb(sd, charid); } if( HPMHooks.count.HP_map_reqnickdb_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *charid); + void (*postHookFunc) (struct map_session_data *sd, int charid); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_reqnickdb_post[hIndex].func; - postHookFunc(sd, &charid); + postHookFunc(sd, charid); } } return; @@ -39995,10 +40169,10 @@ const char* HP_map_charid2nick(int charid) { retVal___ = HPMHooks.source.map.charid2nick(charid); } if( HPMHooks.count.HP_map_charid2nick_post ) { - const char* (*postHookFunc) (const char* retVal___, int *charid); + const char* (*postHookFunc) (const char* retVal___, int charid); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2nick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_charid2nick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &charid); + retVal___ = postHookFunc(retVal___, charid); } } return retVal___; @@ -40022,10 +40196,10 @@ struct map_session_data* HP_map_charid2sd(int charid) { retVal___ = HPMHooks.source.map.charid2sd(charid); } if( HPMHooks.count.HP_map_charid2sd_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *charid); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int charid); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2sd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_charid2sd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &charid); + retVal___ = postHookFunc(retVal___, charid); } } return retVal___; @@ -40033,12 +40207,12 @@ struct map_session_data* HP_map_charid2sd(int charid) { void HP_map_vforeachpc(int ( *func ) (struct map_session_data *sd, va_list args), va_list args) { int hIndex = 0; if( HPMHooks.count.HP_map_vforeachpc_pre ) { - void (*preHookFunc) (int ( *func ) (struct map_session_data *sd, va_list args), va_list args); + void (*preHookFunc) (int ( **func ) (struct map_session_data *sd, va_list args), va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachpc_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachpc_pre[hIndex].func; - preHookFunc(func, args___copy); + preHookFunc(&func, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40065,12 +40239,12 @@ void HP_map_vforeachpc(int ( *func ) (struct map_session_data *sd, va_list args) void HP_map_vforeachmob(int ( *func ) (struct mob_data *md, va_list args), va_list args) { int hIndex = 0; if( HPMHooks.count.HP_map_vforeachmob_pre ) { - void (*preHookFunc) (int ( *func ) (struct mob_data *md, va_list args), va_list args); + void (*preHookFunc) (int ( **func ) (struct mob_data *md, va_list args), va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachmob_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachmob_pre[hIndex].func; - preHookFunc(func, args___copy); + preHookFunc(&func, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40097,12 +40271,12 @@ void HP_map_vforeachmob(int ( *func ) (struct mob_data *md, va_list args), va_li void HP_map_vforeachnpc(int ( *func ) (struct npc_data *nd, va_list args), va_list args) { int hIndex = 0; if( HPMHooks.count.HP_map_vforeachnpc_pre ) { - void (*preHookFunc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args); + void (*preHookFunc) (int ( **func ) (struct npc_data *nd, va_list args), va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachnpc_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachnpc_pre[hIndex].func; - preHookFunc(func, args___copy); + preHookFunc(&func, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40129,12 +40303,12 @@ void HP_map_vforeachnpc(int ( *func ) (struct npc_data *nd, va_list args), va_li void HP_map_vforeachregen(int ( *func ) (struct block_list *bl, va_list args), va_list args) { int hIndex = 0; if( HPMHooks.count.HP_map_vforeachregen_pre ) { - void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args); + void (*preHookFunc) (int ( **func ) (struct block_list *bl, va_list args), va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachregen_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachregen_pre[hIndex].func; - preHookFunc(func, args___copy); + preHookFunc(&func, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40161,12 +40335,12 @@ void HP_map_vforeachregen(int ( *func ) (struct block_list *bl, va_list args), v void HP_map_vforeachiddb(int ( *func ) (struct block_list *bl, va_list args), va_list args) { int hIndex = 0; if( HPMHooks.count.HP_map_vforeachiddb_pre ) { - void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args); + void (*preHookFunc) (int ( **func ) (struct block_list *bl, va_list args), va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachiddb_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachiddb_pre[hIndex].func; - preHookFunc(func, args___copy); + preHookFunc(&func, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40194,12 +40368,12 @@ int HP_map_vforeachinrange(int ( *func ) (struct block_list *, va_list), struct int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinrange_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinrange_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachinrange_pre[hIndex].func; - retVal___ = preHookFunc(func, center, &range, &type, ap___copy); + retVal___ = preHookFunc(&func, ¢er, &range, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40213,11 +40387,11 @@ int HP_map_vforeachinrange(int ( *func ) (struct block_list *, va_list), struct va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachinrange_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinrange_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachinrange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, center, &range, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, center, range, type, ap___copy); va_end(ap___copy); } } @@ -40227,12 +40401,12 @@ int HP_map_vforeachinshootrange(int ( *func ) (struct block_list *, va_list), st int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinshootrange_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinshootrange_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachinshootrange_pre[hIndex].func; - retVal___ = preHookFunc(func, center, &range, &type, ap___copy); + retVal___ = preHookFunc(&func, ¢er, &range, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40246,11 +40420,11 @@ int HP_map_vforeachinshootrange(int ( *func ) (struct block_list *, va_list), st va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachinshootrange_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinshootrange_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachinshootrange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, center, &range, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, center, range, type, ap___copy); va_end(ap___copy); } } @@ -40260,12 +40434,12 @@ int HP_map_vforeachinarea(int ( *func ) (struct block_list *, va_list), int16 m, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinarea_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinarea_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachinarea_pre[hIndex].func; - retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &type, ap___copy); + retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40279,11 +40453,11 @@ int HP_map_vforeachinarea(int ( *func ) (struct block_list *, va_list), int16 m, va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachinarea_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinarea_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachinarea_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, type, ap___copy); va_end(ap___copy); } } @@ -40293,12 +40467,12 @@ int HP_map_vforcountinrange(int ( *func ) (struct block_list *, va_list), struct int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforcountinrange_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *count, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int *count, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinrange_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforcountinrange_pre[hIndex].func; - retVal___ = preHookFunc(func, center, &range, &count, &type, ap___copy); + retVal___ = preHookFunc(&func, ¢er, &range, &count, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40312,11 +40486,11 @@ int HP_map_vforcountinrange(int ( *func ) (struct block_list *, va_list), struct va_end(ap___copy); } if( HPMHooks.count.HP_map_vforcountinrange_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *count, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int count, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinrange_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforcountinrange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, center, &range, &count, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, center, range, count, type, ap___copy); va_end(ap___copy); } } @@ -40326,12 +40500,12 @@ int HP_map_vforcountinarea(int ( *func ) (struct block_list *, va_list), int16 m int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforcountinarea_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinarea_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforcountinarea_pre[hIndex].func; - retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy); + retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40345,11 +40519,11 @@ int HP_map_vforcountinarea(int ( *func ) (struct block_list *, va_list), int16 m va_end(ap___copy); } if( HPMHooks.count.HP_map_vforcountinarea_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinarea_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforcountinarea_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, count, type, ap___copy); va_end(ap___copy); } } @@ -40359,12 +40533,12 @@ int HP_map_vforeachinmovearea(int ( *func ) (struct block_list *, va_list), stru int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinmovearea_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), struct block_list **center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmovearea_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachinmovearea_pre[hIndex].func; - retVal___ = preHookFunc(func, center, &range, &dx, &dy, &type, ap___copy); + retVal___ = preHookFunc(&func, ¢er, &range, &dx, &dy, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40378,11 +40552,11 @@ int HP_map_vforeachinmovearea(int ( *func ) (struct block_list *, va_list), stru va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachinmovearea_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int16 dx, int16 dy, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmovearea_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachinmovearea_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, center, &range, &dx, &dy, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, center, range, dx, dy, type, ap___copy); va_end(ap___copy); } } @@ -40392,12 +40566,12 @@ int HP_map_vforeachincell(int ( *func ) (struct block_list *, va_list), int16 m, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachincell_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachincell_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachincell_pre[hIndex].func; - retVal___ = preHookFunc(func, &m, &x, &y, &type, ap___copy); + retVal___ = preHookFunc(&func, &m, &x, &y, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40411,11 +40585,11 @@ int HP_map_vforeachincell(int ( *func ) (struct block_list *, va_list), int16 m, va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachincell_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x, int16 y, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachincell_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachincell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &m, &x, &y, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, m, x, y, type, ap___copy); va_end(ap___copy); } } @@ -40425,12 +40599,12 @@ int HP_map_vforeachinpath(int ( *func ) (struct block_list *, va_list), int16 m, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinpath_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinpath_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachinpath_pre[hIndex].func; - retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy); + retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40444,11 +40618,11 @@ int HP_map_vforeachinpath(int ( *func ) (struct block_list *, va_list), int16 m, va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachinpath_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinpath_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachinpath_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, range, length, type, ap___copy); va_end(ap___copy); } } @@ -40458,12 +40632,12 @@ int HP_map_vforeachinmap(int ( *func ) (struct block_list *, va_list), int16 m, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachinmap_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int *type, va_list args); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *m, int *type, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmap_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_vforeachinmap_pre[hIndex].func; - retVal___ = preHookFunc(func, &m, &type, args___copy); + retVal___ = preHookFunc(&func, &m, &type, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -40477,11 +40651,11 @@ int HP_map_vforeachinmap(int ( *func ) (struct block_list *, va_list), int16 m, va_end(args___copy); } if( HPMHooks.count.HP_map_vforeachinmap_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int *type, va_list args); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int type, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmap_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_map_vforeachinmap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &m, &type, args___copy); + retVal___ = postHookFunc(retVal___, func, m, type, args___copy); va_end(args___copy); } } @@ -40491,12 +40665,12 @@ int HP_map_vforeachininstance(int ( *func ) (struct block_list *, va_list), int1 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_vforeachininstance_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachininstance_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_vforeachininstance_pre[hIndex].func; - retVal___ = preHookFunc(func, &instance_id, &type, ap___copy); + retVal___ = preHookFunc(&func, &instance_id, &type, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -40510,11 +40684,11 @@ int HP_map_vforeachininstance(int ( *func ) (struct block_list *, va_list), int1 va_end(ap___copy); } if( HPMHooks.count.HP_map_vforeachininstance_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 instance_id, int type, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachininstance_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_vforeachininstance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, &instance_id, &type, ap___copy); + retVal___ = postHookFunc(retVal___, func, instance_id, type, ap___copy); va_end(ap___copy); } } @@ -40539,10 +40713,10 @@ struct map_session_data* HP_map_id2sd(int id) { retVal___ = HPMHooks.source.map.id2sd(id); } if( HPMHooks.count.HP_map_id2sd_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *id); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2sd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2sd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40566,10 +40740,10 @@ struct npc_data* HP_map_id2nd(int id) { retVal___ = HPMHooks.source.map.id2nd(id); } if( HPMHooks.count.HP_map_id2nd_post ) { - struct npc_data* (*postHookFunc) (struct npc_data* retVal___, int *id); + struct npc_data* (*postHookFunc) (struct npc_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2nd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2nd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40593,10 +40767,10 @@ struct mob_data* HP_map_id2md(int id) { retVal___ = HPMHooks.source.map.id2md(id); } if( HPMHooks.count.HP_map_id2md_post ) { - struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int *id); + struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2md_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2md_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40620,10 +40794,10 @@ struct flooritem_data* HP_map_id2fi(int id) { retVal___ = HPMHooks.source.map.id2fi(id); } if( HPMHooks.count.HP_map_id2fi_post ) { - struct flooritem_data* (*postHookFunc) (struct flooritem_data* retVal___, int *id); + struct flooritem_data* (*postHookFunc) (struct flooritem_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2fi_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2fi_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40647,10 +40821,10 @@ struct chat_data* HP_map_id2cd(int id) { retVal___ = HPMHooks.source.map.id2cd(id); } if( HPMHooks.count.HP_map_id2cd_post ) { - struct chat_data* (*postHookFunc) (struct chat_data* retVal___, int *id); + struct chat_data* (*postHookFunc) (struct chat_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2cd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2cd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40674,10 +40848,10 @@ struct skill_unit* HP_map_id2su(int id) { retVal___ = HPMHooks.source.map.id2su(id); } if( HPMHooks.count.HP_map_id2su_post ) { - struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, int *id); + struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2su_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2su_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40701,10 +40875,10 @@ struct pet_data* HP_map_id2pd(int id) { retVal___ = HPMHooks.source.map.id2pd(id); } if( HPMHooks.count.HP_map_id2pd_post ) { - struct pet_data* (*postHookFunc) (struct pet_data* retVal___, int *id); + struct pet_data* (*postHookFunc) (struct pet_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2pd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2pd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40728,10 +40902,10 @@ struct homun_data* HP_map_id2hd(int id) { retVal___ = HPMHooks.source.map.id2hd(id); } if( HPMHooks.count.HP_map_id2hd_post ) { - struct homun_data* (*postHookFunc) (struct homun_data* retVal___, int *id); + struct homun_data* (*postHookFunc) (struct homun_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2hd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2hd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40755,10 +40929,10 @@ struct mercenary_data* HP_map_id2mc(int id) { retVal___ = HPMHooks.source.map.id2mc(id); } if( HPMHooks.count.HP_map_id2mc_post ) { - struct mercenary_data* (*postHookFunc) (struct mercenary_data* retVal___, int *id); + struct mercenary_data* (*postHookFunc) (struct mercenary_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2mc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2mc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40782,10 +40956,10 @@ struct elemental_data* HP_map_id2ed(int id) { retVal___ = HPMHooks.source.map.id2ed(id); } if( HPMHooks.count.HP_map_id2ed_post ) { - struct elemental_data* (*postHookFunc) (struct elemental_data* retVal___, int *id); + struct elemental_data* (*postHookFunc) (struct elemental_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2ed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2ed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40809,10 +40983,10 @@ struct block_list* HP_map_id2bl(int id) { retVal___ = HPMHooks.source.map.id2bl(id); } if( HPMHooks.count.HP_map_id2bl_post ) { - struct block_list* (*postHookFunc) (struct block_list* retVal___, int *id); + struct block_list* (*postHookFunc) (struct block_list* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2bl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2bl_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40836,10 +41010,10 @@ bool HP_map_blid_exists(int id) { retVal___ = HPMHooks.source.map.blid_exists(id); } if( HPMHooks.count.HP_map_blid_exists_post ) { - bool (*postHookFunc) (bool retVal___, int *id); + bool (*postHookFunc) (bool retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_blid_exists_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_blid_exists_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -40863,10 +41037,10 @@ int16 HP_map_mapindex2mapid(unsigned short map_index) { retVal___ = HPMHooks.source.map.mapindex2mapid(map_index); } if( HPMHooks.count.HP_map_mapindex2mapid_post ) { - int16 (*postHookFunc) (int16 retVal___, unsigned short *map_index); + int16 (*postHookFunc) (int16 retVal___, unsigned short map_index); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapindex2mapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_mapindex2mapid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map_index); + retVal___ = postHookFunc(retVal___, map_index); } } return retVal___; @@ -40875,11 +41049,11 @@ int16 HP_map_mapname2mapid(const char *name) { int hIndex = 0; int16 retVal___ = 0; if( HPMHooks.count.HP_map_mapname2mapid_pre ) { - int16 (*preHookFunc) (const char *name); + int16 (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2mapid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_mapname2mapid_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -40902,11 +41076,11 @@ int HP_map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_mapname2ipport_pre ) { - int (*preHookFunc) (unsigned short *name, uint32 *ip, uint16 *port); + int (*preHookFunc) (unsigned short *name, uint32 **ip, uint16 **port); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2ipport_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_mapname2ipport_pre[hIndex].func; - retVal___ = preHookFunc(&name, ip, port); + retVal___ = preHookFunc(&name, &ip, &port); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -40917,10 +41091,10 @@ int HP_map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port) { retVal___ = HPMHooks.source.map.mapname2ipport(name, ip, port); } if( HPMHooks.count.HP_map_mapname2ipport_post ) { - int (*postHookFunc) (int retVal___, unsigned short *name, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, unsigned short name, uint32 *ip, uint16 *port); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2ipport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_mapname2ipport_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &name, ip, port); + retVal___ = postHookFunc(retVal___, name, ip, port); } } return retVal___; @@ -40944,10 +41118,10 @@ int HP_map_setipport(unsigned short map_index, uint32 ip, uint16 port) { retVal___ = HPMHooks.source.map.setipport(map_index, ip, port); } if( HPMHooks.count.HP_map_setipport_post ) { - int (*postHookFunc) (int retVal___, unsigned short *map_index, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, unsigned short map_index, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setipport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_setipport_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map_index, &ip, &port); + retVal___ = postHookFunc(retVal___, map_index, ip, port); } } return retVal___; @@ -40971,10 +41145,10 @@ int HP_map_eraseipport(unsigned short map_index, uint32 ip, uint16 port) { retVal___ = HPMHooks.source.map.eraseipport(map_index, ip, port); } if( HPMHooks.count.HP_map_eraseipport_post ) { - int (*postHookFunc) (int retVal___, unsigned short *map_index, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, unsigned short map_index, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseipport_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_eraseipport_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &map_index, &ip, &port); + retVal___ = postHookFunc(retVal___, map_index, ip, port); } } return retVal___; @@ -41009,11 +41183,11 @@ int HP_map_eraseallipport(void) { void HP_map_addiddb(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_map_addiddb_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addiddb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addiddb_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41035,11 +41209,11 @@ void HP_map_addiddb(struct block_list *bl) { void HP_map_deliddb(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_map_deliddb_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_deliddb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_deliddb_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41062,11 +41236,11 @@ struct map_session_data* HP_map_nick2sd(const char *nick) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_map_nick2sd_pre ) { - struct map_session_data* (*preHookFunc) (const char *nick); + struct map_session_data* (*preHookFunc) (const char **nick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick2sd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_nick2sd_pre[hIndex].func; - retVal___ = preHookFunc(nick); + retVal___ = preHookFunc(&nick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41104,10 +41278,10 @@ struct mob_data* HP_map_getmob_boss(int16 m) { retVal___ = HPMHooks.source.map.getmob_boss(m); } if( HPMHooks.count.HP_map_getmob_boss_post ) { - struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int16 *m); + struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getmob_boss_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_getmob_boss_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m); + retVal___ = postHookFunc(retVal___, m); } } return retVal___; @@ -41131,10 +41305,10 @@ struct mob_data* HP_map_id2boss(int id) { retVal___ = HPMHooks.source.map.id2boss(id); } if( HPMHooks.count.HP_map_id2boss_post ) { - struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int *id); + struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2boss_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_id2boss_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -41158,10 +41332,10 @@ uint32 HP_map_race_id2mask(int race) { retVal___ = HPMHooks.source.map.race_id2mask(race); } if( HPMHooks.count.HP_map_race_id2mask_post ) { - uint32 (*postHookFunc) (uint32 retVal___, int *race); + uint32 (*postHookFunc) (uint32 retVal___, int race); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_race_id2mask_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_race_id2mask_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &race); + retVal___ = postHookFunc(retVal___, race); } } return retVal___; @@ -41184,10 +41358,10 @@ void HP_map_reloadnpc(bool clear) { HPMHooks.source.map.reloadnpc(clear); } if( HPMHooks.count.HP_map_reloadnpc_post ) { - void (*postHookFunc) (bool *clear); + void (*postHookFunc) (bool clear); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_reloadnpc_post[hIndex].func; - postHookFunc(&clear); + postHookFunc(clear); } } return; @@ -41211,10 +41385,10 @@ int HP_map_check_dir(int s_dir, int t_dir) { retVal___ = HPMHooks.source.map.check_dir(s_dir, t_dir); } if( HPMHooks.count.HP_map_check_dir_post ) { - int (*postHookFunc) (int retVal___, int *s_dir, int *t_dir); + int (*postHookFunc) (int retVal___, int s_dir, int t_dir); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_check_dir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_check_dir_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &s_dir, &t_dir); + retVal___ = postHookFunc(retVal___, s_dir, t_dir); } } return retVal___; @@ -41223,11 +41397,11 @@ uint8 HP_map_calc_dir(struct block_list *src, int16 x, int16 y) { int hIndex = 0; uint8 retVal___ = 0; if( HPMHooks.count.HP_map_calc_dir_pre ) { - uint8 (*preHookFunc) (struct block_list *src, int16 *x, int16 *y); + uint8 (*preHookFunc) (struct block_list **src, int16 *x, int16 *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_calc_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_calc_dir_pre[hIndex].func; - retVal___ = preHookFunc(src, &x, &y); + retVal___ = preHookFunc(&src, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41238,10 +41412,10 @@ uint8 HP_map_calc_dir(struct block_list *src, int16 x, int16 y) { retVal___ = HPMHooks.source.map.calc_dir(src, x, y); } if( HPMHooks.count.HP_map_calc_dir_post ) { - uint8 (*postHookFunc) (uint8 retVal___, struct block_list *src, int16 *x, int16 *y); + uint8 (*postHookFunc) (uint8 retVal___, struct block_list *src, int16 x, int16 y); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_calc_dir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_calc_dir_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &x, &y); + retVal___ = postHookFunc(retVal___, src, x, y); } } return retVal___; @@ -41250,11 +41424,11 @@ int HP_map_random_dir(struct block_list *bl, short *x, short *y) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_random_dir_pre ) { - int (*preHookFunc) (struct block_list *bl, short *x, short *y); + int (*preHookFunc) (struct block_list **bl, short **x, short **y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_random_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_random_dir_pre[hIndex].func; - retVal___ = preHookFunc(bl, x, y); + retVal___ = preHookFunc(&bl, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41277,12 +41451,12 @@ int HP_map_cleanup_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_cleanup_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_cleanup_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -41310,11 +41484,11 @@ int HP_map_delmap(char *mapname) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_delmap_pre ) { - int (*preHookFunc) (char *mapname); + int (*preHookFunc) (char **mapname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_delmap_pre[hIndex].func; - retVal___ = preHookFunc(mapname); + retVal___ = preHookFunc(&mapname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41363,11 +41537,11 @@ bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shoota int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_map_iwall_set_pre ) { - bool (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char *wall_name); + bool (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char **wall_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_set_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_iwall_set_pre[hIndex].func; - retVal___ = preHookFunc(&m, &x, &y, &size, &dir, &shootable, wall_name); + retVal___ = preHookFunc(&m, &x, &y, &size, &dir, &shootable, &wall_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41378,10 +41552,10 @@ bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shoota retVal___ = HPMHooks.source.map.iwall_set(m, x, y, size, dir, shootable, wall_name); } if( HPMHooks.count.HP_map_iwall_set_post ) { - bool (*postHookFunc) (bool retVal___, int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char *wall_name); + bool (*postHookFunc) (bool retVal___, int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char *wall_name); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_set_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_iwall_set_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, &x, &y, &size, &dir, &shootable, wall_name); + retVal___ = postHookFunc(retVal___, m, x, y, size, dir, shootable, wall_name); } } return retVal___; @@ -41389,11 +41563,11 @@ bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shoota void HP_map_iwall_get(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_map_iwall_get_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_get_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_iwall_get_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41415,11 +41589,11 @@ void HP_map_iwall_get(struct map_session_data *sd) { void HP_map_iwall_remove(const char *wall_name) { int hIndex = 0; if( HPMHooks.count.HP_map_iwall_remove_pre ) { - void (*preHookFunc) (const char *wall_name); + void (*preHookFunc) (const char **wall_name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_iwall_remove_pre[hIndex].func; - preHookFunc(wall_name); + preHookFunc(&wall_name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41442,11 +41616,11 @@ int HP_map_addmobtolist(unsigned short m, struct spawn_data *spawn) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_addmobtolist_pre ) { - int (*preHookFunc) (unsigned short *m, struct spawn_data *spawn); + int (*preHookFunc) (unsigned short *m, struct spawn_data **spawn); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addmobtolist_pre[hIndex].func; - retVal___ = preHookFunc(&m, spawn); + retVal___ = preHookFunc(&m, &spawn); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41457,10 +41631,10 @@ int HP_map_addmobtolist(unsigned short m, struct spawn_data *spawn) { retVal___ = HPMHooks.source.map.addmobtolist(m, spawn); } if( HPMHooks.count.HP_map_addmobtolist_post ) { - int (*postHookFunc) (int retVal___, unsigned short *m, struct spawn_data *spawn); + int (*postHookFunc) (int retVal___, unsigned short m, struct spawn_data *spawn); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_addmobtolist_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, spawn); + retVal___ = postHookFunc(retVal___, m, spawn); } } return retVal___; @@ -41483,10 +41657,10 @@ void HP_map_spawnmobs(int16 m) { HPMHooks.source.map.spawnmobs(m); } if( HPMHooks.count.HP_map_spawnmobs_post ) { - void (*postHookFunc) (int16 *m); + void (*postHookFunc) (int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_spawnmobs_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_spawnmobs_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -41509,10 +41683,10 @@ void HP_map_removemobs(int16 m) { HPMHooks.source.map.removemobs(m); } if( HPMHooks.count.HP_map_removemobs_post ) { - void (*postHookFunc) (int16 *m); + void (*postHookFunc) (int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_removemobs_post[hIndex].func; - postHookFunc(&m); + postHookFunc(m); } } return; @@ -41520,11 +41694,11 @@ void HP_map_removemobs(int16 m) { void HP_map_addmap2db(struct map_data *m) { int hIndex = 0; if( HPMHooks.count.HP_map_addmap2db_pre ) { - void (*preHookFunc) (struct map_data *m); + void (*preHookFunc) (struct map_data **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap2db_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addmap2db_pre[hIndex].func; - preHookFunc(m); + preHookFunc(&m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41546,11 +41720,11 @@ void HP_map_addmap2db(struct map_data *m) { void HP_map_removemapdb(struct map_data *m) { int hIndex = 0; if( HPMHooks.count.HP_map_removemapdb_pre ) { - void (*preHookFunc) (struct map_data *m); + void (*preHookFunc) (struct map_data **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemapdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_removemapdb_pre[hIndex].func; - preHookFunc(m); + preHookFunc(&m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41587,10 +41761,10 @@ void HP_map_clean(int i) { HPMHooks.source.map.clean(i); } if( HPMHooks.count.HP_map_clean_post ) { - void (*postHookFunc) (int *i); + void (*postHookFunc) (int i); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clean_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_clean_post[hIndex].func; - postHookFunc(&i); + postHookFunc(i); } } return; @@ -41640,10 +41814,10 @@ int HP_map_freeblock_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.map.freeblock_timer(tid, tick, id, data); } if( HPMHooks.count.HP_map_freeblock_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_freeblock_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -41652,11 +41826,11 @@ int HP_map_searchrandfreecell(int16 m, const struct block_list *bl, int16 *x, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_searchrandfreecell_pre ) { - int (*preHookFunc) (int16 *m, const struct block_list *bl, int16 *x, int16 *y, int *stack); + int (*preHookFunc) (int16 *m, const struct block_list **bl, int16 **x, int16 **y, int *stack); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_searchrandfreecell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_searchrandfreecell_pre[hIndex].func; - retVal___ = preHookFunc(&m, bl, x, y, &stack); + retVal___ = preHookFunc(&m, &bl, &x, &y, &stack); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41667,10 +41841,10 @@ int HP_map_searchrandfreecell(int16 m, const struct block_list *bl, int16 *x, in retVal___ = HPMHooks.source.map.searchrandfreecell(m, bl, x, y, stack); } if( HPMHooks.count.HP_map_searchrandfreecell_post ) { - int (*postHookFunc) (int retVal___, int16 *m, const struct block_list *bl, int16 *x, int16 *y, int *stack); + int (*postHookFunc) (int retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int stack); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_searchrandfreecell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_searchrandfreecell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, bl, x, y, &stack); + retVal___ = postHookFunc(retVal___, m, bl, x, y, stack); } } return retVal___; @@ -41679,12 +41853,12 @@ int HP_map_count_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_count_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_count_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -41710,8 +41884,7 @@ int HP_map_count_sub(struct block_list *bl, va_list ap) { } struct DBData HP_map_create_charid2nick(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_map_create_charid2nick_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -41732,11 +41905,11 @@ struct DBData HP_map_create_charid2nick(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_map_create_charid2nick_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_charid2nick_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_map_create_charid2nick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -41746,12 +41919,12 @@ int HP_map_removemobs_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_removemobs_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_removemobs_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -41777,8 +41950,7 @@ int HP_map_removemobs_sub(struct block_list *bl, va_list ap) { } struct mapcell HP_map_gat2cell(int gat) { int hIndex = 0; - struct mapcell retVal___; - memset(&retVal___, '\0', sizeof(struct mapcell)); + struct mapcell retVal___ = { 0 }; if( HPMHooks.count.HP_map_gat2cell_pre ) { struct mapcell (*preHookFunc) (int *gat); *HPMforce_return = false; @@ -41795,10 +41967,10 @@ struct mapcell HP_map_gat2cell(int gat) { retVal___ = HPMHooks.source.map.gat2cell(gat); } if( HPMHooks.count.HP_map_gat2cell_post ) { - struct mapcell (*postHookFunc) (struct mapcell retVal___, int *gat); + struct mapcell (*postHookFunc) (struct mapcell retVal___, int gat); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_gat2cell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_gat2cell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &gat); + retVal___ = postHookFunc(retVal___, gat); } } return retVal___; @@ -41822,10 +41994,10 @@ int HP_map_cell2gat(struct mapcell cell) { retVal___ = HPMHooks.source.map.cell2gat(cell); } if( HPMHooks.count.HP_map_cell2gat_post ) { - int (*postHookFunc) (int retVal___, struct mapcell *cell); + int (*postHookFunc) (int retVal___, struct mapcell cell); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cell2gat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_cell2gat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &cell); + retVal___ = postHookFunc(retVal___, cell); } } return retVal___; @@ -41834,11 +42006,11 @@ int HP_map_getcellp(struct map_data *m, const struct block_list *bl, int16 x, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_getcellp_pre ) { - int (*preHookFunc) (struct map_data *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*preHookFunc) (struct map_data **m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcellp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_getcellp_pre[hIndex].func; - retVal___ = preHookFunc(m, bl, &x, &y, &cellchk); + retVal___ = preHookFunc(&m, &bl, &x, &y, &cellchk); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41849,10 +42021,10 @@ int HP_map_getcellp(struct map_data *m, const struct block_list *bl, int16 x, in retVal___ = HPMHooks.source.map.getcellp(m, bl, x, y, cellchk); } if( HPMHooks.count.HP_map_getcellp_post ) { - int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcellp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_getcellp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, m, bl, &x, &y, &cellchk); + retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk); } } return retVal___; @@ -41875,10 +42047,10 @@ void HP_map_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) { HPMHooks.source.map.setcell(m, x, y, cell, flag); } if( HPMHooks.count.HP_map_setcell_post ) { - void (*postHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag); + void (*postHookFunc) (int16 m, int16 x, int16 y, cell_t cell, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_setcell_post[hIndex].func; - postHookFunc(&m, &x, &y, &cell, &flag); + postHookFunc(m, x, y, cell, flag); } } return; @@ -41887,11 +42059,11 @@ int HP_map_sub_getcellp(struct map_data *m, const struct block_list *bl, int16 x int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_sub_getcellp_pre ) { - int (*preHookFunc) (struct map_data *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*preHookFunc) (struct map_data **m, const struct block_list **bl, int16 *x, int16 *y, cell_chk *cellchk); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_getcellp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_sub_getcellp_pre[hIndex].func; - retVal___ = preHookFunc(m, bl, &x, &y, &cellchk); + retVal___ = preHookFunc(&m, &bl, &x, &y, &cellchk); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41902,10 +42074,10 @@ int HP_map_sub_getcellp(struct map_data *m, const struct block_list *bl, int16 x retVal___ = HPMHooks.source.map.sub_getcellp(m, bl, x, y, cellchk); } if( HPMHooks.count.HP_map_sub_getcellp_post ) { - int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 *x, int16 *y, cell_chk *cellchk); + int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_getcellp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_sub_getcellp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, m, bl, &x, &y, &cellchk); + retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk); } } return retVal___; @@ -41928,10 +42100,10 @@ void HP_map_sub_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) { HPMHooks.source.map.sub_setcell(m, x, y, cell, flag); } if( HPMHooks.count.HP_map_sub_setcell_post ) { - void (*postHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag); + void (*postHookFunc) (int16 m, int16 x, int16 y, cell_t cell, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_setcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_sub_setcell_post[hIndex].func; - postHookFunc(&m, &x, &y, &cell, &flag); + postHookFunc(m, x, y, cell, flag); } } return; @@ -41939,11 +42111,11 @@ void HP_map_sub_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) { void HP_map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1) { int hIndex = 0; if( HPMHooks.count.HP_map_iwall_nextxy_pre ) { - void (*preHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 *x1, int16 *y1); + void (*preHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 **x1, int16 **y1); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_nextxy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_iwall_nextxy_pre[hIndex].func; - preHookFunc(&x, &y, &dir, &pos, x1, y1); + preHookFunc(&x, &y, &dir, &pos, &x1, &y1); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -41954,18 +42126,17 @@ void HP_map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 * HPMHooks.source.map.iwall_nextxy(x, y, dir, pos, x1, y1); } if( HPMHooks.count.HP_map_iwall_nextxy_post ) { - void (*postHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 *x1, int16 *y1); + void (*postHookFunc) (int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_nextxy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_iwall_nextxy_post[hIndex].func; - postHookFunc(&x, &y, &dir, &pos, x1, y1); + postHookFunc(x, y, dir, pos, x1, y1); } } return; } struct DBData HP_map_create_map_data_other_server(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_map_create_map_data_other_server_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -41986,11 +42157,11 @@ struct DBData HP_map_create_map_data_other_server(union DBKey key, va_list args) va_end(args___copy); } if( HPMHooks.count.HP_map_create_map_data_other_server_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_map_data_other_server_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_map_create_map_data_other_server_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -42000,12 +42171,12 @@ int HP_map_eraseallipport_sub(union DBKey key, struct DBData *data, va_list va) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_eraseallipport_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list va); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list va); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_sub_pre; hIndex++ ) { va_list va___copy; va_copy(va___copy, va); preHookFunc = HPMHooks.list.HP_map_eraseallipport_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, va___copy); + retVal___ = preHookFunc(&key, &data, va___copy); va_end(va___copy); } if( *HPMforce_return ) { @@ -42019,11 +42190,11 @@ int HP_map_eraseallipport_sub(union DBKey key, struct DBData *data, va_list va) va_end(va___copy); } if( HPMHooks.count.HP_map_eraseallipport_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list va); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list va); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_sub_post; hIndex++ ) { va_list va___copy; va_copy(va___copy, va); postHookFunc = HPMHooks.list.HP_map_eraseallipport_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, va___copy); + retVal___ = postHookFunc(retVal___, key, data, va___copy); va_end(va___copy); } } @@ -42033,11 +42204,11 @@ char* HP_map_init_mapcache(FILE *fp) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_map_init_mapcache_pre ) { - char* (*preHookFunc) (FILE *fp); + char* (*preHookFunc) (FILE **fp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_init_mapcache_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_init_mapcache_pre[hIndex].func; - retVal___ = preHookFunc(fp); + retVal___ = preHookFunc(&fp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42060,11 +42231,11 @@ int HP_map_readfromcache(struct map_data *m, char *buffer) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_readfromcache_pre ) { - int (*preHookFunc) (struct map_data *m, char *buffer); + int (*preHookFunc) (struct map_data **m, char **buffer); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readfromcache_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_readfromcache_pre[hIndex].func; - retVal___ = preHookFunc(m, buffer); + retVal___ = preHookFunc(&m, &buffer); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42087,11 +42258,11 @@ int HP_map_addmap(const char *mapname) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_addmap_pre ) { - int (*preHookFunc) (const char *mapname); + int (*preHookFunc) (const char **mapname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_addmap_pre[hIndex].func; - retVal___ = preHookFunc(mapname); + retVal___ = preHookFunc(&mapname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42128,10 +42299,10 @@ void HP_map_delmapid(int id) { HPMHooks.source.map.delmapid(id); } if( HPMHooks.count.HP_map_delmapid_post ) { - void (*postHookFunc) (int *id); + void (*postHookFunc) (int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_delmapid_post[hIndex].func; - postHookFunc(&id); + postHookFunc(id); } } return; @@ -42192,11 +42363,11 @@ int HP_map_waterheight(char *mapname) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_waterheight_pre ) { - int (*preHookFunc) (char *mapname); + int (*preHookFunc) (char **mapname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_waterheight_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_waterheight_pre[hIndex].func; - retVal___ = preHookFunc(mapname); + retVal___ = preHookFunc(&mapname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42219,11 +42390,11 @@ int HP_map_readgat(struct map_data *m) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_readgat_pre ) { - int (*preHookFunc) (struct map_data *m); + int (*preHookFunc) (struct map_data **m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readgat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_readgat_pre[hIndex].func; - retVal___ = preHookFunc(m); + retVal___ = preHookFunc(&m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42273,11 +42444,11 @@ int HP_map_config_read(char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_config_read_pre ) { - int (*preHookFunc) (char *cfgName); + int (*preHookFunc) (char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42300,11 +42471,11 @@ int HP_map_config_read_sub(char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_config_read_sub_pre ) { - int (*preHookFunc) (char *cfgName); + int (*preHookFunc) (char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_config_read_sub_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42326,11 +42497,11 @@ int HP_map_config_read_sub(char *cfgName) { void HP_map_reloadnpc_sub(char *cfgName) { int hIndex = 0; if( HPMHooks.count.HP_map_reloadnpc_sub_pre ) { - void (*preHookFunc) (char *cfgName); + void (*preHookFunc) (char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_reloadnpc_sub_pre[hIndex].func; - preHookFunc(cfgName); + preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42353,11 +42524,11 @@ int HP_map_inter_config_read(char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_inter_config_read_pre ) { - int (*preHookFunc) (char *cfgName); + int (*preHookFunc) (char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_inter_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42434,11 +42605,11 @@ bool HP_map_zone_mf_cache(int m, char *flag, char *params) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_map_zone_mf_cache_pre ) { - bool (*preHookFunc) (int *m, char *flag, char *params); + bool (*preHookFunc) (int *m, char **flag, char **params); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_mf_cache_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_mf_cache_pre[hIndex].func; - retVal___ = preHookFunc(&m, flag, params); + retVal___ = preHookFunc(&m, &flag, ¶ms); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42449,10 +42620,10 @@ bool HP_map_zone_mf_cache(int m, char *flag, char *params) { retVal___ = HPMHooks.source.map.zone_mf_cache(m, flag, params); } if( HPMHooks.count.HP_map_zone_mf_cache_post ) { - bool (*postHookFunc) (bool retVal___, int *m, char *flag, char *params); + bool (*postHookFunc) (bool retVal___, int m, char *flag, char *params); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_mf_cache_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_zone_mf_cache_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, flag, params); + retVal___ = postHookFunc(retVal___, m, flag, params); } } return retVal___; @@ -42461,11 +42632,11 @@ unsigned short HP_map_zone_str2itemid(const char *name) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_map_zone_str2itemid_pre ) { - unsigned short (*preHookFunc) (const char *name); + unsigned short (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2itemid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_str2itemid_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42488,11 +42659,11 @@ unsigned short HP_map_zone_str2skillid(const char *name) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_map_zone_str2skillid_pre ) { - unsigned short (*preHookFunc) (const char *name); + unsigned short (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2skillid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_str2skillid_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42515,11 +42686,11 @@ enum bl_type HP_map_zone_bl_type(const char *entry, enum map_zone_skill_subtype int hIndex = 0; enum bl_type retVal___ = BL_NUL; if( HPMHooks.count.HP_map_zone_bl_type_pre ) { - enum bl_type (*preHookFunc) (const char *entry, enum map_zone_skill_subtype *subtype); + enum bl_type (*preHookFunc) (const char **entry, enum map_zone_skill_subtype **subtype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_bl_type_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_bl_type_pre[hIndex].func; - retVal___ = preHookFunc(entry, subtype); + retVal___ = preHookFunc(&entry, &subtype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42568,12 +42739,12 @@ int HP_map_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -42587,11 +42758,11 @@ int HP_map_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_map_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_map_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -42601,12 +42772,12 @@ int HP_map_nick_db_final(union DBKey key, struct DBData *data, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_nick_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list args); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick_db_final_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_map_nick_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, args___copy); + retVal___ = preHookFunc(&key, &data, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -42620,11 +42791,11 @@ int HP_map_nick_db_final(union DBKey key, struct DBData *data, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_map_nick_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list args); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick_db_final_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_map_nick_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, args___copy); + retVal___ = postHookFunc(retVal___, key, data, args___copy); va_end(args___copy); } } @@ -42634,12 +42805,12 @@ int HP_map_cleanup_db_sub(union DBKey key, struct DBData *data, va_list va) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_cleanup_db_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list va); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list va); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_db_sub_pre; hIndex++ ) { va_list va___copy; va_copy(va___copy, va); preHookFunc = HPMHooks.list.HP_map_cleanup_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, va___copy); + retVal___ = preHookFunc(&key, &data, va___copy); va_end(va___copy); } if( *HPMforce_return ) { @@ -42653,11 +42824,11 @@ int HP_map_cleanup_db_sub(union DBKey key, struct DBData *data, va_list va) { va_end(va___copy); } if( HPMHooks.count.HP_map_cleanup_db_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list va); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list va); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_db_sub_post; hIndex++ ) { va_list va___copy; va_copy(va___copy, va); postHookFunc = HPMHooks.list.HP_map_cleanup_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, va___copy); + retVal___ = postHookFunc(retVal___, key, data, va___copy); va_end(va___copy); } } @@ -42667,12 +42838,12 @@ int HP_map_abort_sub(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_map_abort_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_abort_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_map_abort_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -42699,11 +42870,11 @@ int HP_map_abort_sub(struct map_session_data *sd, va_list ap) { void HP_map_update_cell_bl(struct block_list *bl, bool increase) { int hIndex = 0; if( HPMHooks.count.HP_map_update_cell_bl_pre ) { - void (*preHookFunc) (struct block_list *bl, bool *increase); + void (*preHookFunc) (struct block_list **bl, bool *increase); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_update_cell_bl_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_update_cell_bl_pre[hIndex].func; - preHookFunc(bl, &increase); + preHookFunc(&bl, &increase); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42714,10 +42885,10 @@ void HP_map_update_cell_bl(struct block_list *bl, bool increase) { HPMHooks.source.map.update_cell_bl(bl, increase); } if( HPMHooks.count.HP_map_update_cell_bl_post ) { - void (*postHookFunc) (struct block_list *bl, bool *increase); + void (*postHookFunc) (struct block_list *bl, bool increase); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_update_cell_bl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_update_cell_bl_post[hIndex].func; - postHookFunc(bl, &increase); + postHookFunc(bl, increase); } } return; @@ -42752,11 +42923,11 @@ int HP_map_get_new_bonus_id(void) { void HP_map_add_questinfo(int m, struct questinfo *qi) { int hIndex = 0; if( HPMHooks.count.HP_map_add_questinfo_pre ) { - void (*preHookFunc) (int *m, struct questinfo *qi); + void (*preHookFunc) (int *m, struct questinfo **qi); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_add_questinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_add_questinfo_pre[hIndex].func; - preHookFunc(&m, qi); + preHookFunc(&m, &qi); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42767,10 +42938,10 @@ void HP_map_add_questinfo(int m, struct questinfo *qi) { HPMHooks.source.map.add_questinfo(m, qi); } if( HPMHooks.count.HP_map_add_questinfo_post ) { - void (*postHookFunc) (int *m, struct questinfo *qi); + void (*postHookFunc) (int m, struct questinfo *qi); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_add_questinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_add_questinfo_post[hIndex].func; - postHookFunc(&m, qi); + postHookFunc(m, qi); } } return; @@ -42779,11 +42950,11 @@ bool HP_map_remove_questinfo(int m, struct npc_data *nd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_map_remove_questinfo_pre ) { - bool (*preHookFunc) (int *m, struct npc_data *nd); + bool (*preHookFunc) (int *m, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_remove_questinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_remove_questinfo_pre[hIndex].func; - retVal___ = preHookFunc(&m, nd); + retVal___ = preHookFunc(&m, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42794,10 +42965,10 @@ bool HP_map_remove_questinfo(int m, struct npc_data *nd) { retVal___ = HPMHooks.source.map.remove_questinfo(m, nd); } if( HPMHooks.count.HP_map_remove_questinfo_post ) { - bool (*postHookFunc) (bool retVal___, int *m, struct npc_data *nd); + bool (*postHookFunc) (bool retVal___, int m, struct npc_data *nd); for(hIndex = 0; hIndex < HPMHooks.count.HP_map_remove_questinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_map_remove_questinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &m, nd); + retVal___ = postHookFunc(retVal___, m, nd); } } return retVal___; @@ -42806,11 +42977,11 @@ struct map_zone_data* HP_map_merge_zone(struct map_zone_data *main, struct map_z int hIndex = 0; struct map_zone_data* retVal___ = NULL; if( HPMHooks.count.HP_map_merge_zone_pre ) { - struct map_zone_data* (*preHookFunc) (struct map_zone_data *main, struct map_zone_data *other); + struct map_zone_data* (*preHookFunc) (struct map_zone_data **main, struct map_zone_data **other); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_merge_zone_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_merge_zone_pre[hIndex].func; - retVal___ = preHookFunc(main, other); + retVal___ = preHookFunc(&main, &other); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42832,11 +43003,11 @@ struct map_zone_data* HP_map_merge_zone(struct map_zone_data *main, struct map_z void HP_map_zone_clear_single(struct map_zone_data *zone) { int hIndex = 0; if( HPMHooks.count.HP_map_zone_clear_single_pre ) { - void (*preHookFunc) (struct map_zone_data *zone); + void (*preHookFunc) (struct map_zone_data **zone); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_clear_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_map_zone_clear_single_pre[hIndex].func; - preHookFunc(zone); + preHookFunc(&zone); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42913,11 +43084,11 @@ int HP_mapindex_addmap(int index, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapindex_addmap_pre ) { - int (*preHookFunc) (int *index, const char *name); + int (*preHookFunc) (int *index, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_addmap_pre[hIndex].func; - retVal___ = preHookFunc(&index, name); + retVal___ = preHookFunc(&index, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42928,10 +43099,10 @@ int HP_mapindex_addmap(int index, const char *name) { retVal___ = HPMHooks.source.mapindex.addmap(index, name); } if( HPMHooks.count.HP_mapindex_addmap_post ) { - int (*postHookFunc) (int retVal___, int *index, const char *name); + int (*postHookFunc) (int retVal___, int index, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_addmap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &index, name); + retVal___ = postHookFunc(retVal___, index, name); } } return retVal___; @@ -42954,10 +43125,10 @@ void HP_mapindex_removemap(int index) { HPMHooks.source.mapindex.removemap(index); } if( HPMHooks.count.HP_mapindex_removemap_post ) { - void (*postHookFunc) (int *index); + void (*postHookFunc) (int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_removemap_post[hIndex].func; - postHookFunc(&index); + postHookFunc(index); } } return; @@ -42966,11 +43137,11 @@ const char* HP_mapindex_getmapname(const char *string, char *output) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_getmapname_pre ) { - const char* (*preHookFunc) (const char *string, char *output); + const char* (*preHookFunc) (const char **string, char **output); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_getmapname_pre[hIndex].func; - retVal___ = preHookFunc(string, output); + retVal___ = preHookFunc(&string, &output); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -42993,11 +43164,11 @@ const char* HP_mapindex_getmapname_ext(const char *string, char *output) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_getmapname_ext_pre ) { - const char* (*preHookFunc) (const char *string, char *output); + const char* (*preHookFunc) (const char **string, char **output); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_pre[hIndex].func; - retVal___ = preHookFunc(string, output); + retVal___ = preHookFunc(&string, &output); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43020,11 +43191,11 @@ unsigned short HP_mapindex_name2id(const char *p1) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_mapindex_name2id_pre ) { - unsigned short (*preHookFunc) (const char *p1); + unsigned short (*preHookFunc) (const char **p1); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_name2id_pre[hIndex].func; - retVal___ = preHookFunc(p1); + retVal___ = preHookFunc(&p1); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43047,11 +43218,11 @@ const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const cha int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_mapindex_id2name_pre ) { - const char* (*preHookFunc) (uint16 *id, const char *file, int *line, const char *func); + const char* (*preHookFunc) (uint16 *id, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapindex_id2name_pre[hIndex].func; - retVal___ = preHookFunc(&id, file, &line, func); + retVal___ = preHookFunc(&id, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43062,10 +43233,10 @@ const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const cha retVal___ = HPMHooks.source.mapindex.id2name(id, file, line, func); } if( HPMHooks.count.HP_mapindex_id2name_post ) { - const char* (*postHookFunc) (const char* retVal___, uint16 *id, const char *file, int *line, const char *func); + const char* (*postHookFunc) (const char* retVal___, uint16 id, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapindex_id2name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id, file, &line, func); + retVal___ = postHookFunc(retVal___, id, file, line, func); } } return retVal___; @@ -43117,10 +43288,10 @@ struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types retVal___ = HPMHooks.source.mapit.alloc(flags, types); } if( HPMHooks.count.HP_mapit_alloc_post ) { - struct s_mapiterator* (*postHookFunc) (struct s_mapiterator* retVal___, enum e_mapitflags *flags, enum bl_type *types); + struct s_mapiterator* (*postHookFunc) (struct s_mapiterator* retVal___, enum e_mapitflags flags, enum bl_type types); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_alloc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapit_alloc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &flags, &types); + retVal___ = postHookFunc(retVal___, flags, types); } } return retVal___; @@ -43128,11 +43299,11 @@ struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types void HP_mapit_free(struct s_mapiterator *iter) { int hIndex = 0; if( HPMHooks.count.HP_mapit_free_pre ) { - void (*preHookFunc) (struct s_mapiterator *iter); + void (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_free_pre[hIndex].func; - preHookFunc(iter); + preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43155,11 +43326,11 @@ struct block_list* HP_mapit_first(struct s_mapiterator *iter) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mapit_first_pre ) { - struct block_list* (*preHookFunc) (struct s_mapiterator *iter); + struct block_list* (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_first_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_first_pre[hIndex].func; - retVal___ = preHookFunc(iter); + retVal___ = preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43182,11 +43353,11 @@ struct block_list* HP_mapit_last(struct s_mapiterator *iter) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mapit_last_pre ) { - struct block_list* (*preHookFunc) (struct s_mapiterator *iter); + struct block_list* (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_last_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_last_pre[hIndex].func; - retVal___ = preHookFunc(iter); + retVal___ = preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43209,11 +43380,11 @@ struct block_list* HP_mapit_next(struct s_mapiterator *iter) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mapit_next_pre ) { - struct block_list* (*preHookFunc) (struct s_mapiterator *iter); + struct block_list* (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_next_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_next_pre[hIndex].func; - retVal___ = preHookFunc(iter); + retVal___ = preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43236,11 +43407,11 @@ struct block_list* HP_mapit_prev(struct s_mapiterator *iter) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mapit_prev_pre ) { - struct block_list* (*preHookFunc) (struct s_mapiterator *iter); + struct block_list* (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_prev_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_prev_pre[hIndex].func; - retVal___ = preHookFunc(iter); + retVal___ = preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43263,11 +43434,11 @@ bool HP_mapit_exists(struct s_mapiterator *iter) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapit_exists_pre ) { - bool (*preHookFunc) (struct s_mapiterator *iter); + bool (*preHookFunc) (struct s_mapiterator **iter); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_exists_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapit_exists_pre[hIndex].func; - retVal___ = preHookFunc(iter); + retVal___ = preHookFunc(&iter); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43358,10 +43529,10 @@ int HP_mapreg_readreg(int64 uid) { retVal___ = HPMHooks.source.mapreg.readreg(uid); } if( HPMHooks.count.HP_mapreg_readreg_post ) { - int (*postHookFunc) (int retVal___, int64 *uid); + int (*postHookFunc) (int retVal___, int64 uid); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readreg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapreg_readreg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &uid); + retVal___ = postHookFunc(retVal___, uid); } } return retVal___; @@ -43385,10 +43556,10 @@ char* HP_mapreg_readregstr(int64 uid) { retVal___ = HPMHooks.source.mapreg.readregstr(uid); } if( HPMHooks.count.HP_mapreg_readregstr_post ) { - char* (*postHookFunc) (char* retVal___, int64 *uid); + char* (*postHookFunc) (char* retVal___, int64 uid); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readregstr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapreg_readregstr_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &uid); + retVal___ = postHookFunc(retVal___, uid); } } return retVal___; @@ -43412,10 +43583,10 @@ bool HP_mapreg_setreg(int64 uid, int val) { retVal___ = HPMHooks.source.mapreg.setreg(uid, val); } if( HPMHooks.count.HP_mapreg_setreg_post ) { - bool (*postHookFunc) (bool retVal___, int64 *uid, int *val); + bool (*postHookFunc) (bool retVal___, int64 uid, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setreg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapreg_setreg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &uid, &val); + retVal___ = postHookFunc(retVal___, uid, val); } } return retVal___; @@ -43424,11 +43595,11 @@ bool HP_mapreg_setregstr(int64 uid, const char *str) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapreg_setregstr_pre ) { - bool (*preHookFunc) (int64 *uid, const char *str); + bool (*preHookFunc) (int64 *uid, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapreg_setregstr_pre[hIndex].func; - retVal___ = preHookFunc(&uid, str); + retVal___ = preHookFunc(&uid, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43439,10 +43610,10 @@ bool HP_mapreg_setregstr(int64 uid, const char *str) { retVal___ = HPMHooks.source.mapreg.setregstr(uid, str); } if( HPMHooks.count.HP_mapreg_setregstr_post ) { - bool (*postHookFunc) (bool retVal___, int64 *uid, const char *str); + bool (*postHookFunc) (bool retVal___, int64 uid, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapreg_setregstr_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &uid, str); + retVal___ = postHookFunc(retVal___, uid, str); } } return retVal___; @@ -43518,10 +43689,10 @@ int HP_mapreg_save_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mapreg.save_timer(tid, tick, id, data); } if( HPMHooks.count.HP_mapreg_save_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mapreg_save_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -43530,12 +43701,12 @@ int HP_mapreg_destroyreg(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mapreg_destroyreg_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_destroyreg_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mapreg_destroyreg_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -43549,11 +43720,11 @@ int HP_mapreg_destroyreg(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_mapreg_destroyreg_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_destroyreg_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_mapreg_destroyreg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -43589,11 +43760,11 @@ bool HP_mapreg_config_read(const char *w1, const char *w2) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mapreg_config_read_pre ) { - bool (*preHookFunc) (const char *w1, const char *w2); + bool (*preHookFunc) (const char **w1, const char **w2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mapreg_config_read_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2); + retVal___ = preHookFunc(&w1, &w2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43631,10 +43802,10 @@ void HP_mercenary_init(bool minimal) { HPMHooks.source.mercenary.init(minimal); } if( HPMHooks.count.HP_mercenary_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -43658,10 +43829,10 @@ bool HP_mercenary_class(int class_) { retVal___ = HPMHooks.source.mercenary.class(class_); } if( HPMHooks.count.HP_mercenary_class_post ) { - bool (*postHookFunc) (bool retVal___, int *class_); + bool (*postHookFunc) (bool retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_class_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_class_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -43685,10 +43856,10 @@ struct view_data* HP_mercenary_get_viewdata(int class_) { retVal___ = HPMHooks.source.mercenary.get_viewdata(class_); } if( HPMHooks.count.HP_mercenary_get_viewdata_post ) { - struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_); + struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_get_viewdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -43697,11 +43868,11 @@ int HP_mercenary_create(struct map_session_data *sd, int class_, unsigned int li int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime); + int (*preHookFunc) (struct map_session_data **sd, int *class_, unsigned int *lifetime); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, &class_, &lifetime); + retVal___ = preHookFunc(&sd, &class_, &lifetime); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43712,10 +43883,10 @@ int HP_mercenary_create(struct map_session_data *sd, int class_, unsigned int li retVal___ = HPMHooks.source.mercenary.create(sd, class_, lifetime); } if( HPMHooks.count.HP_mercenary_create_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_, unsigned int *lifetime); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &class_, &lifetime); + retVal___ = postHookFunc(retVal___, sd, class_, lifetime); } } return retVal___; @@ -43724,11 +43895,11 @@ int HP_mercenary_data_received(const struct s_mercenary *merc, bool flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_data_received_pre ) { - int (*preHookFunc) (const struct s_mercenary *merc, bool *flag); + int (*preHookFunc) (const struct s_mercenary **merc, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_data_received_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_data_received_pre[hIndex].func; - retVal___ = preHookFunc(merc, &flag); + retVal___ = preHookFunc(&merc, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43739,10 +43910,10 @@ int HP_mercenary_data_received(const struct s_mercenary *merc, bool flag) { retVal___ = HPMHooks.source.mercenary.data_received(merc, flag); } if( HPMHooks.count.HP_mercenary_data_received_post ) { - int (*postHookFunc) (int retVal___, const struct s_mercenary *merc, bool *flag); + int (*postHookFunc) (int retVal___, const struct s_mercenary *merc, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_data_received_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_data_received_post[hIndex].func; - retVal___ = postHookFunc(retVal___, merc, &flag); + retVal___ = postHookFunc(retVal___, merc, flag); } } return retVal___; @@ -43751,11 +43922,11 @@ int HP_mercenary_save(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_save_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_save_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43777,11 +43948,11 @@ int HP_mercenary_save(struct mercenary_data *md) { void HP_mercenary_heal(struct mercenary_data *md, int hp, int sp) { int hIndex = 0; if( HPMHooks.count.HP_mercenary_heal_pre ) { - void (*preHookFunc) (struct mercenary_data *md, int *hp, int *sp); + void (*preHookFunc) (struct mercenary_data **md, int *hp, int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_heal_pre[hIndex].func; - preHookFunc(md, &hp, &sp); + preHookFunc(&md, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43792,10 +43963,10 @@ void HP_mercenary_heal(struct mercenary_data *md, int hp, int sp) { HPMHooks.source.mercenary.heal(md, hp, sp); } if( HPMHooks.count.HP_mercenary_heal_post ) { - void (*postHookFunc) (struct mercenary_data *md, int *hp, int *sp); + void (*postHookFunc) (struct mercenary_data *md, int hp, int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_heal_post[hIndex].func; - postHookFunc(md, &hp, &sp); + postHookFunc(md, hp, sp); } } return; @@ -43804,11 +43975,11 @@ int HP_mercenary_dead(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_dead_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_dead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_dead_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43831,11 +44002,11 @@ int HP_mercenary_delete(struct mercenary_data *md, int reply) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_delete_pre ) { - int (*preHookFunc) (struct mercenary_data *md, int *reply); + int (*preHookFunc) (struct mercenary_data **md, int *reply); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_delete_pre[hIndex].func; - retVal___ = preHookFunc(md, &reply); + retVal___ = preHookFunc(&md, &reply); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43846,10 +44017,10 @@ int HP_mercenary_delete(struct mercenary_data *md, int reply) { retVal___ = HPMHooks.source.mercenary.delete(md, reply); } if( HPMHooks.count.HP_mercenary_delete_post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *reply); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, int reply); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &reply); + retVal___ = postHookFunc(retVal___, md, reply); } } return retVal___; @@ -43857,11 +44028,11 @@ int HP_mercenary_delete(struct mercenary_data *md, int reply) { void HP_mercenary_contract_stop(struct mercenary_data *md) { int hIndex = 0; if( HPMHooks.count.HP_mercenary_contract_stop_pre ) { - void (*preHookFunc) (struct mercenary_data *md); + void (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_stop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_contract_stop_pre[hIndex].func; - preHookFunc(md); + preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43884,11 +44055,11 @@ int HP_mercenary_get_lifetime(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_get_lifetime_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_lifetime_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_get_lifetime_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43911,11 +44082,11 @@ int HP_mercenary_get_guild(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_get_guild_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_guild_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_get_guild_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43938,11 +44109,11 @@ int HP_mercenary_get_faith(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_get_faith_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_faith_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_get_faith_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43965,11 +44136,11 @@ int HP_mercenary_set_faith(struct mercenary_data *md, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_set_faith_pre ) { - int (*preHookFunc) (struct mercenary_data *md, int *value); + int (*preHookFunc) (struct mercenary_data **md, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_faith_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_set_faith_pre[hIndex].func; - retVal___ = preHookFunc(md, &value); + retVal___ = preHookFunc(&md, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -43980,10 +44151,10 @@ int HP_mercenary_set_faith(struct mercenary_data *md, int value) { retVal___ = HPMHooks.source.mercenary.set_faith(md, value); } if( HPMHooks.count.HP_mercenary_set_faith_post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *value); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_faith_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_set_faith_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &value); + retVal___ = postHookFunc(retVal___, md, value); } } return retVal___; @@ -43992,11 +44163,11 @@ int HP_mercenary_get_calls(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_get_calls_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_calls_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_get_calls_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44019,11 +44190,11 @@ int HP_mercenary_set_calls(struct mercenary_data *md, int value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_set_calls_pre ) { - int (*preHookFunc) (struct mercenary_data *md, int *value); + int (*preHookFunc) (struct mercenary_data **md, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_calls_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_set_calls_pre[hIndex].func; - retVal___ = preHookFunc(md, &value); + retVal___ = preHookFunc(&md, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44034,10 +44205,10 @@ int HP_mercenary_set_calls(struct mercenary_data *md, int value) { retVal___ = HPMHooks.source.mercenary.set_calls(md, value); } if( HPMHooks.count.HP_mercenary_set_calls_post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *value); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_calls_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_set_calls_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &value); + retVal___ = postHookFunc(retVal___, md, value); } } return retVal___; @@ -44046,11 +44217,11 @@ int HP_mercenary_kills(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_kills_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_kills_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_kills_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44073,11 +44244,11 @@ int HP_mercenary_checkskill(struct mercenary_data *md, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_checkskill_pre ) { - int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id); + int (*preHookFunc) (struct mercenary_data **md, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_checkskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_checkskill_pre[hIndex].func; - retVal___ = preHookFunc(md, &skill_id); + retVal___ = preHookFunc(&md, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44088,10 +44259,10 @@ int HP_mercenary_checkskill(struct mercenary_data *md, uint16 skill_id) { retVal___ = HPMHooks.source.mercenary.checkskill(md, skill_id); } if( HPMHooks.count.HP_mercenary_checkskill_post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_checkskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_checkskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &skill_id); + retVal___ = postHookFunc(retVal___, md, skill_id); } } return retVal___; @@ -44154,11 +44325,11 @@ int HP_mercenary_killbonus(struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mercenary_killbonus_pre ) { - int (*preHookFunc) (struct mercenary_data *md); + int (*preHookFunc) (struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_killbonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_killbonus_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44196,10 +44367,10 @@ int HP_mercenary_search_index(int class_) { retVal___ = HPMHooks.source.mercenary.search_index(class_); } if( HPMHooks.count.HP_mercenary_search_index_post ) { - int (*postHookFunc) (int retVal___, int *class_); + int (*postHookFunc) (int retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_search_index_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_search_index_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -44223,10 +44394,10 @@ int HP_mercenary_contract_end_timer(int tid, int64 tick, int id, intptr_t data) retVal___ = HPMHooks.source.mercenary.contract_end_timer(tid, tick, id, data); } if( HPMHooks.count.HP_mercenary_contract_end_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_end_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_contract_end_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -44235,11 +44406,11 @@ bool HP_mercenary_read_db_sub(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mercenary_read_db_sub_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_read_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44250,10 +44421,10 @@ bool HP_mercenary_read_db_sub(char *str[], int columns, int current) { retVal___ = HPMHooks.source.mercenary.read_db_sub(str, columns, current); } if( HPMHooks.count.HP_mercenary_read_db_sub_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_read_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -44262,11 +44433,11 @@ bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mercenary_read_skill_db_sub_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skill_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mercenary_read_skill_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44277,10 +44448,10 @@ bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) { retVal___ = HPMHooks.source.mercenary.read_skill_db_sub(str, columns, current); } if( HPMHooks.count.HP_mercenary_read_skill_db_sub_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skill_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mercenary_read_skill_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -44305,10 +44476,10 @@ int HP_mob_init(bool mimimal) { retVal___ = HPMHooks.source.mob.init(mimimal); } if( HPMHooks.count.HP_mob_init_post ) { - int (*postHookFunc) (int retVal___, bool *mimimal); + 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___, &mimimal); + retVal___ = postHookFunc(retVal___, mimimal); } } return retVal___; @@ -44385,10 +44556,10 @@ struct mob_db* HP_mob_db(int index) { retVal___ = HPMHooks.source.mob.db(index); } if( HPMHooks.count.HP_mob_db_post ) { - struct mob_db* (*postHookFunc) (struct mob_db* retVal___, int *index); + struct mob_db* (*postHookFunc) (struct mob_db* retVal___, int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_db_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &index); + retVal___ = postHookFunc(retVal___, index); } } return retVal___; @@ -44412,10 +44583,10 @@ struct mob_chat* HP_mob_chat(short id) { retVal___ = HPMHooks.source.mob.chat(id); } if( HPMHooks.count.HP_mob_chat_post ) { - struct mob_chat* (*postHookFunc) (struct mob_chat* retVal___, short *id); + struct mob_chat* (*postHookFunc) (struct mob_chat* retVal___, short id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_chat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_chat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -44439,10 +44610,10 @@ int HP_mob_makedummymobdb(int p1) { retVal___ = HPMHooks.source.mob.makedummymobdb(p1); } if( HPMHooks.count.HP_mob_makedummymobdb_post ) { - int (*postHookFunc) (int retVal___, int *p1); + int (*postHookFunc) (int retVal___, int p1); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_makedummymobdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_makedummymobdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &p1); + retVal___ = postHookFunc(retVal___, p1); } } return retVal___; @@ -44466,10 +44637,10 @@ int HP_mob_spawn_guardian_sub(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.spawn_guardian_sub(tid, tick, id, data); } if( HPMHooks.count.HP_mob_spawn_guardian_sub_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -44493,10 +44664,10 @@ int HP_mob_skill_id2skill_idx(int class_, uint16 skill_id) { retVal___ = HPMHooks.source.mob.skill_id2skill_idx(class_, skill_id); } if( HPMHooks.count.HP_mob_skill_id2skill_idx_post ) { - int (*postHookFunc) (int retVal___, int *class_, uint16 *skill_id); + int (*postHookFunc) (int retVal___, int class_, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_id2skill_idx_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_skill_id2skill_idx_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_, &skill_id); + retVal___ = postHookFunc(retVal___, class_, skill_id); } } return retVal___; @@ -44505,11 +44676,11 @@ int HP_mob_db_searchname(const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_db_searchname_pre ) { - int (*preHookFunc) (const char *str); + int (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_db_searchname_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44532,11 +44703,11 @@ int HP_mob_db_searchname_array_sub(struct mob_db *monster, const char *str, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_db_searchname_array_sub_pre ) { - int (*preHookFunc) (struct mob_db *monster, const char *str, int *flag); + int (*preHookFunc) (struct mob_db **monster, const char **str, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_db_searchname_array_sub_pre[hIndex].func; - retVal___ = preHookFunc(monster, str, &flag); + retVal___ = preHookFunc(&monster, &str, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44547,10 +44718,10 @@ int HP_mob_db_searchname_array_sub(struct mob_db *monster, const char *str, int retVal___ = HPMHooks.source.mob.db_searchname_array_sub(monster, str, flag); } if( HPMHooks.count.HP_mob_db_searchname_array_sub_post ) { - int (*postHookFunc) (int retVal___, struct mob_db *monster, const char *str, int *flag); + int (*postHookFunc) (int retVal___, struct mob_db *monster, const char *str, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, monster, str, &flag); + retVal___ = postHookFunc(retVal___, monster, str, flag); } } return retVal___; @@ -44558,11 +44729,11 @@ int HP_mob_db_searchname_array_sub(struct mob_db *monster, const char *str, int void HP_mob_mvptomb_create(struct mob_data *md, char *killer, time_t time) { int hIndex = 0; if( HPMHooks.count.HP_mob_mvptomb_create_pre ) { - void (*preHookFunc) (struct mob_data *md, char *killer, time_t *time); + void (*preHookFunc) (struct mob_data **md, char **killer, time_t *time); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_mvptomb_create_pre[hIndex].func; - preHookFunc(md, killer, &time); + preHookFunc(&md, &killer, &time); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44573,10 +44744,10 @@ void HP_mob_mvptomb_create(struct mob_data *md, char *killer, time_t time) { HPMHooks.source.mob.mvptomb_create(md, killer, time); } if( HPMHooks.count.HP_mob_mvptomb_create_post ) { - void (*postHookFunc) (struct mob_data *md, char *killer, time_t *time); + void (*postHookFunc) (struct mob_data *md, char *killer, time_t time); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_mvptomb_create_post[hIndex].func; - postHookFunc(md, killer, &time); + postHookFunc(md, killer, time); } } return; @@ -44584,11 +44755,11 @@ void HP_mob_mvptomb_create(struct mob_data *md, char *killer, time_t time) { void HP_mob_mvptomb_destroy(struct mob_data *md) { int hIndex = 0; if( HPMHooks.count.HP_mob_mvptomb_destroy_pre ) { - void (*preHookFunc) (struct mob_data *md); + void (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_mvptomb_destroy_pre[hIndex].func; - preHookFunc(md); + preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44611,11 +44782,11 @@ int HP_mob_db_searchname_array(struct mob_db **data, int size, const char *str, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_db_searchname_array_pre ) { - int (*preHookFunc) (struct mob_db **data, int *size, const char *str, int *flag); + int (*preHookFunc) (struct mob_db ***data, int *size, const char **str, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_db_searchname_array_pre[hIndex].func; - retVal___ = preHookFunc(data, &size, str, &flag); + retVal___ = preHookFunc(&data, &size, &str, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44626,10 +44797,10 @@ int HP_mob_db_searchname_array(struct mob_db **data, int size, const char *str, retVal___ = HPMHooks.source.mob.db_searchname_array(data, size, str, flag); } if( HPMHooks.count.HP_mob_db_searchname_array_post ) { - int (*postHookFunc) (int retVal___, struct mob_db **data, int *size, const char *str, int *flag); + int (*postHookFunc) (int retVal___, struct mob_db **data, int size, const char *str, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_post[hIndex].func; - retVal___ = postHookFunc(retVal___, data, &size, str, &flag); + retVal___ = postHookFunc(retVal___, data, size, str, flag); } } return retVal___; @@ -44653,10 +44824,10 @@ int HP_mob_db_checkid(const int id) { retVal___ = HPMHooks.source.mob.db_checkid(id); } if( HPMHooks.count.HP_mob_db_checkid_post ) { - int (*postHookFunc) (int retVal___, const int *id); + int (*postHookFunc) (int retVal___, const int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_checkid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_db_checkid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -44680,10 +44851,10 @@ struct view_data* HP_mob_get_viewdata(int class_) { retVal___ = HPMHooks.source.mob.get_viewdata(class_); } if( HPMHooks.count.HP_mob_get_viewdata_post ) { - struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_); + struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_get_viewdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -44692,11 +44863,11 @@ int HP_mob_parse_dataset(struct spawn_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_parse_dataset_pre ) { - int (*preHookFunc) (struct spawn_data *data); + int (*preHookFunc) (struct spawn_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dataset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_parse_dataset_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44719,11 +44890,11 @@ struct mob_data* HP_mob_spawn_dataset(struct spawn_data *data) { int hIndex = 0; struct mob_data* retVal___ = NULL; if( HPMHooks.count.HP_mob_spawn_dataset_pre ) { - struct mob_data* (*preHookFunc) (struct spawn_data *data); + struct mob_data* (*preHookFunc) (struct spawn_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_dataset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_spawn_dataset_pre[hIndex].func; - retVal___ = preHookFunc(data); + retVal___ = preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44761,10 +44932,10 @@ int HP_mob_get_random_id(int type, int flag, int lv) { retVal___ = HPMHooks.source.mob.get_random_id(type, flag, lv); } if( HPMHooks.count.HP_mob_get_random_id_post ) { - int (*postHookFunc) (int retVal___, int *type, int *flag, int *lv); + int (*postHookFunc) (int retVal___, int type, int flag, int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_random_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_get_random_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type, &flag, &lv); + retVal___ = postHookFunc(retVal___, type, flag, lv); } } return retVal___; @@ -44773,11 +44944,11 @@ bool HP_mob_ksprotected(struct block_list *src, struct block_list *target) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_ksprotected_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *target); + bool (*preHookFunc) (struct block_list **src, struct block_list **target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ksprotected_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_ksprotected_pre[hIndex].func; - retVal___ = preHookFunc(src, target); + retVal___ = preHookFunc(&src, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44800,11 +44971,11 @@ struct mob_data* HP_mob_once_spawn_sub(struct block_list *bl, int16 m, int16 x, int hIndex = 0; struct mob_data* retVal___ = NULL; if( HPMHooks.count.HP_mob_once_spawn_sub_pre ) { - struct mob_data* (*preHookFunc) (struct block_list *bl, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, const char *event, unsigned int *size, unsigned int *ai); + struct mob_data* (*preHookFunc) (struct block_list **bl, int16 *m, int16 *x, int16 *y, const char **mobname, int *class_, const char **event, unsigned int *size, unsigned int *ai); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_once_spawn_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, &m, &x, &y, mobname, &class_, event, &size, &ai); + retVal___ = preHookFunc(&bl, &m, &x, &y, &mobname, &class_, &event, &size, &ai); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44815,10 +44986,10 @@ struct mob_data* HP_mob_once_spawn_sub(struct block_list *bl, int16 m, int16 x, retVal___ = HPMHooks.source.mob.once_spawn_sub(bl, m, x, y, mobname, class_, event, size, ai); } if( HPMHooks.count.HP_mob_once_spawn_sub_post ) { - struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct block_list *bl, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, const char *event, unsigned int *size, unsigned int *ai); + struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct block_list *bl, int16 m, int16 x, int16 y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_once_spawn_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &m, &x, &y, mobname, &class_, event, &size, &ai); + retVal___ = postHookFunc(retVal___, bl, m, x, y, mobname, class_, event, size, ai); } } return retVal___; @@ -44827,11 +44998,11 @@ int HP_mob_once_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, co int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_once_spawn_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai); + int (*preHookFunc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y, const char **mobname, int *class_, int *amount, const char **event, unsigned int *size, unsigned int *ai); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_once_spawn_pre[hIndex].func; - retVal___ = preHookFunc(sd, &m, &x, &y, mobname, &class_, &amount, event, &size, &ai); + retVal___ = preHookFunc(&sd, &m, &x, &y, &mobname, &class_, &amount, &event, &size, &ai); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44842,10 +45013,10 @@ int HP_mob_once_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, co retVal___ = HPMHooks.source.mob.once_spawn(sd, m, x, y, mobname, class_, amount, event, size, ai); } if( HPMHooks.count.HP_mob_once_spawn_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_once_spawn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &m, &x, &y, mobname, &class_, &amount, event, &size, &ai); + retVal___ = postHookFunc(retVal___, sd, m, x, y, mobname, class_, amount, event, size, ai); } } return retVal___; @@ -44854,11 +45025,11 @@ int HP_mob_once_spawn_area(struct map_session_data *sd, int16 m, int16 x0, int16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_once_spawn_area_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai); + int (*preHookFunc) (struct map_session_data **sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char **mobname, int *class_, int *amount, const char **event, unsigned int *size, unsigned int *ai); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_area_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_once_spawn_area_pre[hIndex].func; - retVal___ = preHookFunc(sd, &m, &x0, &y0, &x1, &y1, mobname, &class_, &amount, event, &size, &ai); + retVal___ = preHookFunc(&sd, &m, &x0, &y0, &x1, &y1, &mobname, &class_, &amount, &event, &size, &ai); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44869,10 +45040,10 @@ int HP_mob_once_spawn_area(struct map_session_data *sd, int16 m, int16 x0, int16 retVal___ = HPMHooks.source.mob.once_spawn_area(sd, m, x0, y0, x1, y1, mobname, class_, amount, event, size, ai); } if( HPMHooks.count.HP_mob_once_spawn_area_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_area_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_once_spawn_area_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &m, &x0, &y0, &x1, &y1, mobname, &class_, &amount, event, &size, &ai); + retVal___ = postHookFunc(retVal___, sd, m, x0, y0, x1, y1, mobname, class_, amount, event, size, ai); } } return retVal___; @@ -44881,11 +45052,11 @@ int HP_mob_spawn_guardian(const char *mapname, short x, short y, const char *mob int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_spawn_guardian_pre ) { - int (*preHookFunc) (const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, int *guardian, bool *has_index); + int (*preHookFunc) (const char **mapname, short *x, short *y, const char **mobname, int *class_, const char **event, int *guardian, bool *has_index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_spawn_guardian_pre[hIndex].func; - retVal___ = preHookFunc(mapname, &x, &y, mobname, &class_, event, &guardian, &has_index); + retVal___ = preHookFunc(&mapname, &x, &y, &mobname, &class_, &event, &guardian, &has_index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44896,10 +45067,10 @@ int HP_mob_spawn_guardian(const char *mapname, short x, short y, const char *mob retVal___ = HPMHooks.source.mob.spawn_guardian(mapname, x, y, mobname, class_, event, guardian, has_index); } if( HPMHooks.count.HP_mob_spawn_guardian_post ) { - int (*postHookFunc) (int retVal___, const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, int *guardian, bool *has_index); + int (*postHookFunc) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, int guardian, bool has_index); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mapname, &x, &y, mobname, &class_, event, &guardian, &has_index); + retVal___ = postHookFunc(retVal___, mapname, x, y, mobname, class_, event, guardian, has_index); } } return retVal___; @@ -44908,11 +45079,11 @@ int HP_mob_spawn_bg(const char *mapname, short x, short y, const char *mobname, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_spawn_bg_pre ) { - int (*preHookFunc) (const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, unsigned int *bg_id); + int (*preHookFunc) (const char **mapname, short *x, short *y, const char **mobname, int *class_, const char **event, unsigned int *bg_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_bg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_spawn_bg_pre[hIndex].func; - retVal___ = preHookFunc(mapname, &x, &y, mobname, &class_, event, &bg_id); + retVal___ = preHookFunc(&mapname, &x, &y, &mobname, &class_, &event, &bg_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44923,10 +45094,10 @@ int HP_mob_spawn_bg(const char *mapname, short x, short y, const char *mobname, retVal___ = HPMHooks.source.mob.spawn_bg(mapname, x, y, mobname, class_, event, bg_id); } if( HPMHooks.count.HP_mob_spawn_bg_post ) { - int (*postHookFunc) (int retVal___, const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, unsigned int *bg_id); + int (*postHookFunc) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, unsigned int bg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_bg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_spawn_bg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mapname, &x, &y, mobname, &class_, event, &bg_id); + retVal___ = postHookFunc(retVal___, mapname, x, y, mobname, class_, event, bg_id); } } return retVal___; @@ -44935,11 +45106,11 @@ int HP_mob_can_reach(struct mob_data *md, struct block_list *bl, int range, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_can_reach_pre ) { - int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *range, int *state); + int (*preHookFunc) (struct mob_data **md, struct block_list **bl, int *range, int *state); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_reach_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_can_reach_pre[hIndex].func; - retVal___ = preHookFunc(md, bl, &range, &state); + retVal___ = preHookFunc(&md, &bl, &range, &state); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -44950,10 +45121,10 @@ int HP_mob_can_reach(struct mob_data *md, struct block_list *bl, int range, int retVal___ = HPMHooks.source.mob.can_reach(md, bl, range, state); } if( HPMHooks.count.HP_mob_can_reach_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int *range, int *state); + int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int range, int state); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_reach_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_can_reach_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, bl, &range, &state); + retVal___ = postHookFunc(retVal___, md, bl, range, state); } } return retVal___; @@ -44962,12 +45133,12 @@ int HP_mob_linksearch(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_linksearch_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_linksearch_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_linksearch_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45010,10 +45181,10 @@ int HP_mob_delayspawn(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.delayspawn(tid, tick, id, data); } if( HPMHooks.count.HP_mob_delayspawn_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delayspawn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_delayspawn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45022,11 +45193,11 @@ int HP_mob_setdelayspawn(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_setdelayspawn_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdelayspawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_setdelayspawn_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45049,12 +45220,12 @@ int HP_mob_count_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_count_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_count_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_count_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45082,11 +45253,11 @@ int HP_mob_spawn(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_spawn_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_spawn_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45109,11 +45280,11 @@ int HP_mob_can_changetarget(const struct mob_data *md, const struct block_list * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_can_changetarget_pre ) { - int (*preHookFunc) (const struct mob_data *md, const struct block_list *target, uint32 *mode); + int (*preHookFunc) (const struct mob_data **md, const struct block_list **target, uint32 *mode); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_changetarget_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_can_changetarget_pre[hIndex].func; - retVal___ = preHookFunc(md, target, &mode); + retVal___ = preHookFunc(&md, &target, &mode); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45124,10 +45295,10 @@ int HP_mob_can_changetarget(const struct mob_data *md, const struct block_list * retVal___ = HPMHooks.source.mob.can_changetarget(md, target, mode); } if( HPMHooks.count.HP_mob_can_changetarget_post ) { - int (*postHookFunc) (int retVal___, const struct mob_data *md, const struct block_list *target, uint32 *mode); + int (*postHookFunc) (int retVal___, const struct mob_data *md, const struct block_list *target, uint32 mode); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_changetarget_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_can_changetarget_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, target, &mode); + retVal___ = postHookFunc(retVal___, md, target, mode); } } return retVal___; @@ -45136,11 +45307,11 @@ int HP_mob_target(struct mob_data *md, struct block_list *bl, int dist) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_target_pre ) { - int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *dist); + int (*preHookFunc) (struct mob_data **md, struct block_list **bl, int *dist); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_target_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_target_pre[hIndex].func; - retVal___ = preHookFunc(md, bl, &dist); + retVal___ = preHookFunc(&md, &bl, &dist); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45151,10 +45322,10 @@ int HP_mob_target(struct mob_data *md, struct block_list *bl, int dist) { retVal___ = HPMHooks.source.mob.target(md, bl, dist); } if( HPMHooks.count.HP_mob_target_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int *dist); + int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int dist); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_target_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_target_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, bl, &dist); + retVal___ = postHookFunc(retVal___, md, bl, dist); } } return retVal___; @@ -45163,12 +45334,12 @@ int HP_mob_ai_sub_hard_activesearch(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_activesearch_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_activesearch_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_activesearch_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45196,12 +45367,12 @@ int HP_mob_ai_sub_hard_changechase(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_changechase_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_changechase_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_changechase_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45229,12 +45400,12 @@ int HP_mob_ai_sub_hard_bg_ally(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_bg_ally_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45262,12 +45433,12 @@ int HP_mob_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_lootsearch_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45295,12 +45466,12 @@ int HP_mob_warpchase_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_warpchase_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_warpchase_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45328,11 +45499,11 @@ int HP_mob_ai_sub_hard_slavemob(struct mob_data *md, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_pre ) { - int (*preHookFunc) (struct mob_data *md, int64 *tick); + int (*preHookFunc) (struct mob_data **md, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_slavemob_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_slavemob_pre[hIndex].func; - retVal___ = preHookFunc(md, &tick); + retVal___ = preHookFunc(&md, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45343,10 +45514,10 @@ int HP_mob_ai_sub_hard_slavemob(struct mob_data *md, int64 tick) { retVal___ = HPMHooks.source.mob.ai_sub_hard_slavemob(md, tick); } if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, int64 *tick); + int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_slavemob_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &tick); + retVal___ = postHookFunc(retVal___, md, tick); } } return retVal___; @@ -45355,11 +45526,11 @@ int HP_mob_unlocktarget(struct mob_data *md, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_unlocktarget_pre ) { - int (*preHookFunc) (struct mob_data *md, int64 *tick); + int (*preHookFunc) (struct mob_data **md, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_unlocktarget_pre[hIndex].func; - retVal___ = preHookFunc(md, &tick); + retVal___ = preHookFunc(&md, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45370,10 +45541,10 @@ int HP_mob_unlocktarget(struct mob_data *md, int64 tick) { retVal___ = HPMHooks.source.mob.unlocktarget(md, tick); } if( HPMHooks.count.HP_mob_unlocktarget_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, int64 *tick); + int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_unlocktarget_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &tick); + retVal___ = postHookFunc(retVal___, md, tick); } } return retVal___; @@ -45382,11 +45553,11 @@ int HP_mob_randomwalk(struct mob_data *md, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_randomwalk_pre ) { - int (*preHookFunc) (struct mob_data *md, int64 *tick); + int (*preHookFunc) (struct mob_data **md, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_randomwalk_pre[hIndex].func; - retVal___ = preHookFunc(md, &tick); + retVal___ = preHookFunc(&md, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45397,10 +45568,10 @@ int HP_mob_randomwalk(struct mob_data *md, int64 tick) { retVal___ = HPMHooks.source.mob.randomwalk(md, tick); } if( HPMHooks.count.HP_mob_randomwalk_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, int64 *tick); + int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_randomwalk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &tick); + retVal___ = postHookFunc(retVal___, md, tick); } } return retVal___; @@ -45409,11 +45580,11 @@ int HP_mob_warpchase(struct mob_data *md, struct block_list *target) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_warpchase_pre ) { - int (*preHookFunc) (struct mob_data *md, struct block_list *target); + int (*preHookFunc) (struct mob_data **md, struct block_list **target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_warpchase_pre[hIndex].func; - retVal___ = preHookFunc(md, target); + retVal___ = preHookFunc(&md, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45436,11 +45607,11 @@ bool HP_mob_ai_sub_hard(struct mob_data *md, int64 tick) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_ai_sub_hard_pre ) { - bool (*preHookFunc) (struct mob_data *md, int64 *tick); + bool (*preHookFunc) (struct mob_data **md, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_pre[hIndex].func; - retVal___ = preHookFunc(md, &tick); + retVal___ = preHookFunc(&md, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45451,10 +45622,10 @@ bool HP_mob_ai_sub_hard(struct mob_data *md, int64 tick) { retVal___ = HPMHooks.source.mob.ai_sub_hard(md, tick); } if( HPMHooks.count.HP_mob_ai_sub_hard_post ) { - bool (*postHookFunc) (bool retVal___, struct mob_data *md, int64 *tick); + bool (*postHookFunc) (bool retVal___, struct mob_data *md, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &tick); + retVal___ = postHookFunc(retVal___, md, tick); } } return retVal___; @@ -45463,12 +45634,12 @@ int HP_mob_ai_sub_hard_timer(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_hard_timer_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_timer_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_timer_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45496,12 +45667,12 @@ int HP_mob_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_foreachclient_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_foreachclient_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_ai_sub_foreachclient_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45529,12 +45700,12 @@ int HP_mob_ai_sub_lazy(struct mob_data *md, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_ai_sub_lazy_pre ) { - int (*preHookFunc) (struct mob_data *md, va_list args); + int (*preHookFunc) (struct mob_data **md, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_lazy_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_mob_ai_sub_lazy_pre[hIndex].func; - retVal___ = preHookFunc(md, args___copy); + retVal___ = preHookFunc(&md, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -45577,10 +45748,10 @@ int HP_mob_ai_lazy(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.ai_lazy(tid, tick, id, data); } if( HPMHooks.count.HP_mob_ai_lazy_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_lazy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_ai_lazy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45604,10 +45775,10 @@ int HP_mob_ai_hard(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.ai_hard(tid, tick, id, data); } if( HPMHooks.count.HP_mob_ai_hard_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_hard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_ai_hard_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45616,11 +45787,11 @@ struct item_drop* HP_mob_setdropitem(int nameid, int qty, struct item_data *data int hIndex = 0; struct item_drop* retVal___ = NULL; if( HPMHooks.count.HP_mob_setdropitem_pre ) { - struct item_drop* (*preHookFunc) (int *nameid, int *qty, struct item_data *data); + struct item_drop* (*preHookFunc) (int *nameid, int *qty, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdropitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_setdropitem_pre[hIndex].func; - retVal___ = preHookFunc(&nameid, &qty, data); + retVal___ = preHookFunc(&nameid, &qty, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45631,10 +45802,10 @@ struct item_drop* HP_mob_setdropitem(int nameid, int qty, struct item_data *data retVal___ = HPMHooks.source.mob.setdropitem(nameid, qty, data); } if( HPMHooks.count.HP_mob_setdropitem_post ) { - struct item_drop* (*postHookFunc) (struct item_drop* retVal___, int *nameid, int *qty, struct item_data *data); + struct item_drop* (*postHookFunc) (struct item_drop* retVal___, int nameid, int qty, struct item_data *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdropitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_setdropitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &nameid, &qty, data); + retVal___ = postHookFunc(retVal___, nameid, qty, data); } } return retVal___; @@ -45643,11 +45814,11 @@ struct item_drop* HP_mob_setlootitem(struct item *item) { int hIndex = 0; struct item_drop* retVal___ = NULL; if( HPMHooks.count.HP_mob_setlootitem_pre ) { - struct item_drop* (*preHookFunc) (struct item *item); + struct item_drop* (*preHookFunc) (struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setlootitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_setlootitem_pre[hIndex].func; - retVal___ = preHookFunc(item); + retVal___ = preHookFunc(&item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45685,10 +45856,10 @@ int HP_mob_delay_item_drop(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.delay_item_drop(tid, tick, id, data); } if( HPMHooks.count.HP_mob_delay_item_drop_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delay_item_drop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_delay_item_drop_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45696,11 +45867,11 @@ int HP_mob_delay_item_drop(int tid, int64 tick, int id, intptr_t data) { void HP_mob_item_drop(struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag) { int hIndex = 0; if( HPMHooks.count.HP_mob_item_drop_pre ) { - void (*preHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int *loot, int *drop_rate, unsigned short *flag); + void (*preHookFunc) (struct mob_data **md, struct item_drop_list **dlist, struct item_drop **ditem, int *loot, int *drop_rate, unsigned short *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_drop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_item_drop_pre[hIndex].func; - preHookFunc(md, dlist, ditem, &loot, &drop_rate, &flag); + preHookFunc(&md, &dlist, &ditem, &loot, &drop_rate, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45711,10 +45882,10 @@ void HP_mob_item_drop(struct mob_data *md, struct item_drop_list *dlist, struct HPMHooks.source.mob.item_drop(md, dlist, ditem, loot, drop_rate, flag); } if( HPMHooks.count.HP_mob_item_drop_post ) { - void (*postHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int *loot, int *drop_rate, unsigned short *flag); + void (*postHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_drop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_item_drop_post[hIndex].func; - postHookFunc(md, dlist, ditem, &loot, &drop_rate, &flag); + postHookFunc(md, dlist, ditem, loot, drop_rate, flag); } } return; @@ -45738,10 +45909,10 @@ int HP_mob_timer_delete(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.timer_delete(tid, tick, id, data); } if( HPMHooks.count.HP_mob_timer_delete_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_timer_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_timer_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45750,12 +45921,12 @@ int HP_mob_deleteslave_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_deleteslave_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_deleteslave_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -45783,11 +45954,11 @@ int HP_mob_deleteslave(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_deleteslave_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_deleteslave_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45825,10 +45996,10 @@ int HP_mob_respawn(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.mob.respawn(tid, tick, id, data); } if( HPMHooks.count.HP_mob_respawn_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_respawn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_respawn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -45836,11 +46007,11 @@ int HP_mob_respawn(int tid, int64 tick, int id, intptr_t data) { void HP_mob_log_damage(struct mob_data *md, struct block_list *src, int damage) { int hIndex = 0; if( HPMHooks.count.HP_mob_log_damage_pre ) { - void (*preHookFunc) (struct mob_data *md, struct block_list *src, int *damage); + void (*preHookFunc) (struct mob_data **md, struct block_list **src, int *damage); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_log_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_log_damage_pre[hIndex].func; - preHookFunc(md, src, &damage); + preHookFunc(&md, &src, &damage); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45851,10 +46022,10 @@ void HP_mob_log_damage(struct mob_data *md, struct block_list *src, int damage) HPMHooks.source.mob.log_damage(md, src, damage); } if( HPMHooks.count.HP_mob_log_damage_post ) { - void (*postHookFunc) (struct mob_data *md, struct block_list *src, int *damage); + void (*postHookFunc) (struct mob_data *md, struct block_list *src, int damage); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_log_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_log_damage_post[hIndex].func; - postHookFunc(md, src, &damage); + postHookFunc(md, src, damage); } } return; @@ -45862,11 +46033,11 @@ void HP_mob_log_damage(struct mob_data *md, struct block_list *src, int damage) void HP_mob_damage(struct mob_data *md, struct block_list *src, int damage) { int hIndex = 0; if( HPMHooks.count.HP_mob_damage_pre ) { - void (*preHookFunc) (struct mob_data *md, struct block_list *src, int *damage); + void (*preHookFunc) (struct mob_data **md, struct block_list **src, int *damage); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_damage_pre[hIndex].func; - preHookFunc(md, src, &damage); + preHookFunc(&md, &src, &damage); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45877,10 +46048,10 @@ void HP_mob_damage(struct mob_data *md, struct block_list *src, int damage) { HPMHooks.source.mob.damage(md, src, damage); } if( HPMHooks.count.HP_mob_damage_post ) { - void (*postHookFunc) (struct mob_data *md, struct block_list *src, int *damage); + void (*postHookFunc) (struct mob_data *md, struct block_list *src, int damage); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_damage_post[hIndex].func; - postHookFunc(md, src, &damage); + postHookFunc(md, src, damage); } } return; @@ -45889,11 +46060,11 @@ int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_dead_pre ) { - int (*preHookFunc) (struct mob_data *md, struct block_list *src, int *type); + int (*preHookFunc) (struct mob_data **md, struct block_list **src, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_dead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_dead_pre[hIndex].func; - retVal___ = preHookFunc(md, src, &type); + retVal___ = preHookFunc(&md, &src, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45904,10 +46075,10 @@ int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) { retVal___ = HPMHooks.source.mob.dead(md, src, type); } if( HPMHooks.count.HP_mob_dead_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int *type); + int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_dead_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_dead_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, src, &type); + retVal___ = postHookFunc(retVal___, md, src, type); } } return retVal___; @@ -45915,11 +46086,11 @@ int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) { void HP_mob_revive(struct mob_data *md, unsigned int hp) { int hIndex = 0; if( HPMHooks.count.HP_mob_revive_pre ) { - void (*preHookFunc) (struct mob_data *md, unsigned int *hp); + void (*preHookFunc) (struct mob_data **md, unsigned int *hp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_revive_pre[hIndex].func; - preHookFunc(md, &hp); + preHookFunc(&md, &hp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45930,10 +46101,10 @@ void HP_mob_revive(struct mob_data *md, unsigned int hp) { HPMHooks.source.mob.revive(md, hp); } if( HPMHooks.count.HP_mob_revive_post ) { - void (*postHookFunc) (struct mob_data *md, unsigned int *hp); + void (*postHookFunc) (struct mob_data *md, unsigned int hp); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_revive_post[hIndex].func; - postHookFunc(md, &hp); + postHookFunc(md, hp); } } return; @@ -45942,11 +46113,11 @@ int HP_mob_guardian_guildchange(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_guardian_guildchange_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_guardian_guildchange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_guardian_guildchange_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45969,11 +46140,11 @@ int HP_mob_random_class(int *value, size_t count) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_random_class_pre ) { - int (*preHookFunc) (int *value, size_t *count); + int (*preHookFunc) (int **value, size_t *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_random_class_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_random_class_pre[hIndex].func; - retVal___ = preHookFunc(value, &count); + retVal___ = preHookFunc(&value, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -45984,10 +46155,10 @@ int HP_mob_random_class(int *value, size_t count) { retVal___ = HPMHooks.source.mob.random_class(value, count); } if( HPMHooks.count.HP_mob_random_class_post ) { - int (*postHookFunc) (int retVal___, int *value, size_t *count); + int (*postHookFunc) (int retVal___, int *value, size_t count); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_random_class_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_random_class_post[hIndex].func; - retVal___ = postHookFunc(retVal___, value, &count); + retVal___ = postHookFunc(retVal___, value, count); } } return retVal___; @@ -45996,11 +46167,11 @@ int HP_mob_class_change(struct mob_data *md, int class_) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_class_change_pre ) { - int (*preHookFunc) (struct mob_data *md, int *class_); + int (*preHookFunc) (struct mob_data **md, int *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_class_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_class_change_pre[hIndex].func; - retVal___ = preHookFunc(md, &class_); + retVal___ = preHookFunc(&md, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46011,10 +46182,10 @@ int HP_mob_class_change(struct mob_data *md, int class_) { retVal___ = HPMHooks.source.mob.class_change(md, class_); } if( HPMHooks.count.HP_mob_class_change_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, int *class_); + int (*postHookFunc) (int retVal___, struct mob_data *md, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_class_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_class_change_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &class_); + retVal___ = postHookFunc(retVal___, md, class_); } } return retVal___; @@ -46022,11 +46193,11 @@ int HP_mob_class_change(struct mob_data *md, int class_) { void HP_mob_heal(struct mob_data *md, unsigned int heal) { int hIndex = 0; if( HPMHooks.count.HP_mob_heal_pre ) { - void (*preHookFunc) (struct mob_data *md, unsigned int *heal); + void (*preHookFunc) (struct mob_data **md, unsigned int *heal); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_heal_pre[hIndex].func; - preHookFunc(md, &heal); + preHookFunc(&md, &heal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46037,10 +46208,10 @@ void HP_mob_heal(struct mob_data *md, unsigned int heal) { HPMHooks.source.mob.heal(md, heal); } if( HPMHooks.count.HP_mob_heal_post ) { - void (*postHookFunc) (struct mob_data *md, unsigned int *heal); + void (*postHookFunc) (struct mob_data *md, unsigned int heal); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_heal_post[hIndex].func; - postHookFunc(md, &heal); + postHookFunc(md, heal); } } return; @@ -46049,12 +46220,12 @@ int HP_mob_warpslave_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_warpslave_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_warpslave_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -46082,11 +46253,11 @@ int HP_mob_warpslave(struct block_list *bl, int range) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_warpslave_pre ) { - int (*preHookFunc) (struct block_list *bl, int *range); + int (*preHookFunc) (struct block_list **bl, int *range); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_warpslave_pre[hIndex].func; - retVal___ = preHookFunc(bl, &range); + retVal___ = preHookFunc(&bl, &range); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46097,10 +46268,10 @@ int HP_mob_warpslave(struct block_list *bl, int range) { retVal___ = HPMHooks.source.mob.warpslave(bl, range); } if( HPMHooks.count.HP_mob_warpslave_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *range); + int (*postHookFunc) (int retVal___, struct block_list *bl, int range); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_warpslave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &range); + retVal___ = postHookFunc(retVal___, bl, range); } } return retVal___; @@ -46109,12 +46280,12 @@ int HP_mob_countslave_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_countslave_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_countslave_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -46142,11 +46313,11 @@ int HP_mob_countslave(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_countslave_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_countslave_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46169,11 +46340,11 @@ int HP_mob_summonslave(struct mob_data *md2, int *value, int amount, uint16 skil int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_summonslave_pre ) { - int (*preHookFunc) (struct mob_data *md2, int *value, int *amount, uint16 *skill_id); + int (*preHookFunc) (struct mob_data **md2, int **value, int *amount, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_summonslave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_summonslave_pre[hIndex].func; - retVal___ = preHookFunc(md2, value, &amount, &skill_id); + retVal___ = preHookFunc(&md2, &value, &amount, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46184,10 +46355,10 @@ int HP_mob_summonslave(struct mob_data *md2, int *value, int amount, uint16 skil retVal___ = HPMHooks.source.mob.summonslave(md2, value, amount, skill_id); } if( HPMHooks.count.HP_mob_summonslave_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md2, int *value, int *amount, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct mob_data *md2, int *value, int amount, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_summonslave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_summonslave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md2, value, &amount, &skill_id); + retVal___ = postHookFunc(retVal___, md2, value, amount, skill_id); } } return retVal___; @@ -46196,12 +46367,12 @@ int HP_mob_getfriendhprate_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_getfriendhprate_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_getfriendhprate_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -46229,11 +46400,11 @@ struct block_list* HP_mob_getfriendhprate(struct mob_data *md, int min_rate, int int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mob_getfriendhprate_pre ) { - struct block_list* (*preHookFunc) (struct mob_data *md, int *min_rate, int *max_rate); + struct block_list* (*preHookFunc) (struct mob_data **md, int *min_rate, int *max_rate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_getfriendhprate_pre[hIndex].func; - retVal___ = preHookFunc(md, &min_rate, &max_rate); + retVal___ = preHookFunc(&md, &min_rate, &max_rate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46244,10 +46415,10 @@ struct block_list* HP_mob_getfriendhprate(struct mob_data *md, int min_rate, int retVal___ = HPMHooks.source.mob.getfriendhprate(md, min_rate, max_rate); } if( HPMHooks.count.HP_mob_getfriendhprate_post ) { - struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int *min_rate, int *max_rate); + struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int min_rate, int max_rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_getfriendhprate_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &min_rate, &max_rate); + retVal___ = postHookFunc(retVal___, md, min_rate, max_rate); } } return retVal___; @@ -46256,11 +46427,11 @@ struct block_list* HP_mob_getmasterhpltmaxrate(struct mob_data *md, int rate) { int hIndex = 0; struct block_list* retVal___ = NULL; if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre ) { - struct block_list* (*preHookFunc) (struct mob_data *md, int *rate); + struct block_list* (*preHookFunc) (struct mob_data **md, int *rate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_pre[hIndex].func; - retVal___ = preHookFunc(md, &rate); + retVal___ = preHookFunc(&md, &rate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46271,10 +46442,10 @@ struct block_list* HP_mob_getmasterhpltmaxrate(struct mob_data *md, int rate) { retVal___ = HPMHooks.source.mob.getmasterhpltmaxrate(md, rate); } if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_post ) { - struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int *rate); + struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &rate); + retVal___ = postHookFunc(retVal___, md, rate); } } return retVal___; @@ -46283,12 +46454,12 @@ int HP_mob_getfriendstatus_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_getfriendstatus_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_mob_getfriendstatus_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -46316,11 +46487,11 @@ struct mob_data* HP_mob_getfriendstatus(struct mob_data *md, int cond1, int cond int hIndex = 0; struct mob_data* retVal___ = NULL; if( HPMHooks.count.HP_mob_getfriendstatus_pre ) { - struct mob_data* (*preHookFunc) (struct mob_data *md, int *cond1, int *cond2); + struct mob_data* (*preHookFunc) (struct mob_data **md, int *cond1, int *cond2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_getfriendstatus_pre[hIndex].func; - retVal___ = preHookFunc(md, &cond1, &cond2); + retVal___ = preHookFunc(&md, &cond1, &cond2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46331,10 +46502,10 @@ struct mob_data* HP_mob_getfriendstatus(struct mob_data *md, int cond1, int cond retVal___ = HPMHooks.source.mob.getfriendstatus(md, cond1, cond2); } if( HPMHooks.count.HP_mob_getfriendstatus_post ) { - struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct mob_data *md, int *cond1, int *cond2); + struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct mob_data *md, int cond1, int cond2); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_getfriendstatus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &cond1, &cond2); + retVal___ = postHookFunc(retVal___, md, cond1, cond2); } } return retVal___; @@ -46343,11 +46514,11 @@ int HP_mob_skill_use(struct mob_data *md, int64 tick, int event) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_skill_use_pre ) { - int (*preHookFunc) (struct mob_data *md, int64 *tick, int *event); + int (*preHookFunc) (struct mob_data **md, int64 *tick, int *event); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_use_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_skill_use_pre[hIndex].func; - retVal___ = preHookFunc(md, &tick, &event); + retVal___ = preHookFunc(&md, &tick, &event); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46358,10 +46529,10 @@ int HP_mob_skill_use(struct mob_data *md, int64 tick, int event) { retVal___ = HPMHooks.source.mob.skill_use(md, tick, event); } if( HPMHooks.count.HP_mob_skill_use_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, int64 *tick, int *event); + int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick, int event); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_use_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_skill_use_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &tick, &event); + retVal___ = postHookFunc(retVal___, md, tick, event); } } return retVal___; @@ -46370,11 +46541,11 @@ int HP_mob_skill_event(struct mob_data *md, struct block_list *src, int64 tick, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_skill_event_pre ) { - int (*preHookFunc) (struct mob_data *md, struct block_list *src, int64 *tick, int *flag); + int (*preHookFunc) (struct mob_data **md, struct block_list **src, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_skill_event_pre[hIndex].func; - retVal___ = preHookFunc(md, src, &tick, &flag); + retVal___ = preHookFunc(&md, &src, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46385,10 +46556,10 @@ int HP_mob_skill_event(struct mob_data *md, struct block_list *src, int64 tick, retVal___ = HPMHooks.source.mob.skill_event(md, src, tick, flag); } if( HPMHooks.count.HP_mob_skill_event_post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_event_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_skill_event_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, src, &tick, &flag); + retVal___ = postHookFunc(retVal___, md, src, tick, flag); } } return retVal___; @@ -46412,10 +46583,10 @@ int HP_mob_is_clone(int class_) { retVal___ = HPMHooks.source.mob.is_clone(class_); } if( HPMHooks.count.HP_mob_is_clone_post ) { - int (*postHookFunc) (int retVal___, int *class_); + int (*postHookFunc) (int retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_is_clone_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_is_clone_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -46424,11 +46595,11 @@ int HP_mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_clone_spawn_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *event, int *master_id, uint32 *mode, int *flag, unsigned int *duration); + int (*preHookFunc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y, const char **event, int *master_id, uint32 *mode, int *flag, unsigned int *duration); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_spawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_clone_spawn_pre[hIndex].func; - retVal___ = preHookFunc(sd, &m, &x, &y, event, &master_id, &mode, &flag, &duration); + retVal___ = preHookFunc(&sd, &m, &x, &y, &event, &master_id, &mode, &flag, &duration); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46439,10 +46610,10 @@ int HP_mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, c retVal___ = HPMHooks.source.mob.clone_spawn(sd, m, x, y, event, master_id, mode, flag, duration); } if( HPMHooks.count.HP_mob_clone_spawn_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *event, int *master_id, uint32 *mode, int *flag, unsigned int *duration); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, uint32 mode, int flag, unsigned int duration); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_spawn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_clone_spawn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &m, &x, &y, event, &master_id, &mode, &flag, &duration); + retVal___ = postHookFunc(retVal___, sd, m, x, y, event, master_id, mode, flag, duration); } } return retVal___; @@ -46451,11 +46622,11 @@ int HP_mob_clone_delete(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_clone_delete_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_clone_delete_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46493,10 +46664,10 @@ unsigned int HP_mob_drop_adjust(int baserate, int rate_adjust, unsigned short ra retVal___ = HPMHooks.source.mob.drop_adjust(baserate, rate_adjust, rate_min, rate_max); } if( HPMHooks.count.HP_mob_drop_adjust_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, int *baserate, int *rate_adjust, unsigned short *rate_min, unsigned short *rate_max); + unsigned int (*postHookFunc) (unsigned int retVal___, int baserate, int rate_adjust, unsigned short rate_min, unsigned short rate_max); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_drop_adjust_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_drop_adjust_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &baserate, &rate_adjust, &rate_min, &rate_max); + retVal___ = postHookFunc(retVal___, baserate, rate_adjust, rate_min, rate_max); } } return retVal___; @@ -46504,11 +46675,11 @@ unsigned int HP_mob_drop_adjust(int baserate, int rate_adjust, unsigned short ra void HP_mob_item_dropratio_adjust(int nameid, int mob_id, int *rate_adjust) { int hIndex = 0; if( HPMHooks.count.HP_mob_item_dropratio_adjust_pre ) { - void (*preHookFunc) (int *nameid, int *mob_id, int *rate_adjust); + void (*preHookFunc) (int *nameid, int *mob_id, int **rate_adjust); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_dropratio_adjust_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_item_dropratio_adjust_pre[hIndex].func; - preHookFunc(&nameid, &mob_id, rate_adjust); + preHookFunc(&nameid, &mob_id, &rate_adjust); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46519,10 +46690,10 @@ void HP_mob_item_dropratio_adjust(int nameid, int mob_id, int *rate_adjust) { HPMHooks.source.mob.item_dropratio_adjust(nameid, mob_id, rate_adjust); } if( HPMHooks.count.HP_mob_item_dropratio_adjust_post ) { - void (*postHookFunc) (int *nameid, int *mob_id, int *rate_adjust); + void (*postHookFunc) (int nameid, int mob_id, int *rate_adjust); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_dropratio_adjust_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_item_dropratio_adjust_post[hIndex].func; - postHookFunc(&nameid, &mob_id, rate_adjust); + postHookFunc(nameid, mob_id, rate_adjust); } } return; @@ -46557,11 +46728,11 @@ bool HP_mob_lookup_const(const struct config_setting_t *it, const char *name, in int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_lookup_const_pre ) { - bool (*preHookFunc) (const struct config_setting_t *it, const char *name, int *value); + bool (*preHookFunc) (const struct config_setting_t **it, const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_lookup_const_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_lookup_const_pre[hIndex].func; - retVal___ = preHookFunc(it, name, value); + retVal___ = preHookFunc(&it, &name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46584,11 +46755,11 @@ bool HP_mob_get_const(const struct config_setting_t *it, int *value) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_get_const_pre ) { - bool (*preHookFunc) (const struct config_setting_t *it, int *value); + bool (*preHookFunc) (const struct config_setting_t **it, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_const_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_get_const_pre[hIndex].func; - retVal___ = preHookFunc(it, value); + retVal___ = preHookFunc(&it, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46611,11 +46782,11 @@ int HP_mob_db_validate_entry(struct mob_db *entry, int n, const char *source) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_db_validate_entry_pre ) { - int (*preHookFunc) (struct mob_db *entry, int *n, const char *source); + int (*preHookFunc) (struct mob_db **entry, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_validate_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_db_validate_entry_pre[hIndex].func; - retVal___ = preHookFunc(entry, &n, source); + retVal___ = preHookFunc(&entry, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46626,10 +46797,10 @@ int HP_mob_db_validate_entry(struct mob_db *entry, int n, const char *source) { retVal___ = HPMHooks.source.mob.db_validate_entry(entry, n, source); } if( HPMHooks.count.HP_mob_db_validate_entry_post ) { - int (*postHookFunc) (int retVal___, struct mob_db *entry, int *n, const char *source); + int (*postHookFunc) (int retVal___, struct mob_db *entry, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_validate_entry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_db_validate_entry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, entry, &n, source); + retVal___ = postHookFunc(retVal___, entry, n, source); } } return retVal___; @@ -46638,11 +46809,11 @@ int HP_mob_read_libconfig(const char *filename, bool ignore_missing) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_read_libconfig_pre ) { - int (*preHookFunc) (const char *filename, bool *ignore_missing); + int (*preHookFunc) (const char **filename, bool *ignore_missing); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_libconfig_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_libconfig_pre[hIndex].func; - retVal___ = preHookFunc(filename, &ignore_missing); + retVal___ = preHookFunc(&filename, &ignore_missing); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46653,10 +46824,10 @@ int HP_mob_read_libconfig(const char *filename, bool ignore_missing) { retVal___ = HPMHooks.source.mob.read_libconfig(filename, ignore_missing); } if( HPMHooks.count.HP_mob_read_libconfig_post ) { - int (*postHookFunc) (int retVal___, const char *filename, bool *ignore_missing); + int (*postHookFunc) (int retVal___, const char *filename, bool ignore_missing); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_libconfig_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_read_libconfig_post[hIndex].func; - retVal___ = postHookFunc(retVal___, filename, &ignore_missing); + retVal___ = postHookFunc(retVal___, filename, ignore_missing); } } return retVal___; @@ -46664,11 +46835,11 @@ int HP_mob_read_libconfig(const char *filename, bool ignore_missing) { void HP_mob_read_db_additional_fields(struct mob_db *entry, struct config_setting_t *it, int n, const char *source) { int hIndex = 0; if( HPMHooks.count.HP_mob_read_db_additional_fields_pre ) { - void (*preHookFunc) (struct mob_db *entry, struct config_setting_t *it, int *n, const char *source); + void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **it, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_additional_fields_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_additional_fields_pre[hIndex].func; - preHookFunc(entry, it, &n, source); + preHookFunc(&entry, &it, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46679,10 +46850,10 @@ void HP_mob_read_db_additional_fields(struct mob_db *entry, struct config_settin HPMHooks.source.mob.read_db_additional_fields(entry, it, n, source); } if( HPMHooks.count.HP_mob_read_db_additional_fields_post ) { - void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *it, int *n, const char *source); + void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *it, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_additional_fields_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_read_db_additional_fields_post[hIndex].func; - postHookFunc(entry, it, &n, source); + postHookFunc(entry, it, n, source); } } return; @@ -46691,11 +46862,11 @@ int HP_mob_read_db_sub(struct config_setting_t *mobt, int id, const char *source int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_mob_read_db_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *mobt, int *id, const char *source); + int (*preHookFunc) (struct config_setting_t **mobt, int *id, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(mobt, &id, source); + retVal___ = preHookFunc(&mobt, &id, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46706,10 +46877,10 @@ int HP_mob_read_db_sub(struct config_setting_t *mobt, int id, const char *source retVal___ = HPMHooks.source.mob.read_db_sub(mobt, id, source); } if( HPMHooks.count.HP_mob_read_db_sub_post ) { - int (*postHookFunc) (int retVal___, struct config_setting_t *mobt, int *id, const char *source); + int (*postHookFunc) (int retVal___, struct config_setting_t *mobt, int id, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_read_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, mobt, &id, source); + retVal___ = postHookFunc(retVal___, mobt, id, source); } } return retVal___; @@ -46717,11 +46888,11 @@ int HP_mob_read_db_sub(struct config_setting_t *mobt, int id, const char *source void HP_mob_read_db_drops_sub(struct mob_db *entry, struct config_setting_t *t) { int hIndex = 0; if( HPMHooks.count.HP_mob_read_db_drops_sub_pre ) { - void (*preHookFunc) (struct mob_db *entry, struct config_setting_t *t); + void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_drops_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_drops_sub_pre[hIndex].func; - preHookFunc(entry, t); + preHookFunc(&entry, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46743,11 +46914,11 @@ void HP_mob_read_db_drops_sub(struct mob_db *entry, struct config_setting_t *t) void HP_mob_read_db_mvpdrops_sub(struct mob_db *entry, struct config_setting_t *t) { int hIndex = 0; if( HPMHooks.count.HP_mob_read_db_mvpdrops_sub_pre ) { - void (*preHookFunc) (struct mob_db *entry, struct config_setting_t *t); + void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mvpdrops_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_mvpdrops_sub_pre[hIndex].func; - preHookFunc(entry, t); + preHookFunc(&entry, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46770,11 +46941,11 @@ uint32 HP_mob_read_db_mode_sub(struct mob_db *entry, struct config_setting_t *t) int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_mob_read_db_mode_sub_pre ) { - uint32 (*preHookFunc) (struct mob_db *entry, struct config_setting_t *t); + uint32 (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mode_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_mode_sub_pre[hIndex].func; - retVal___ = preHookFunc(entry, t); + retVal___ = preHookFunc(&entry, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46796,11 +46967,11 @@ uint32 HP_mob_read_db_mode_sub(struct mob_db *entry, struct config_setting_t *t) void HP_mob_read_db_stats_sub(struct mob_db *entry, struct config_setting_t *t) { int hIndex = 0; if( HPMHooks.count.HP_mob_read_db_stats_sub_pre ) { - void (*preHookFunc) (struct mob_db *entry, struct config_setting_t *t); + void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_stats_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_read_db_stats_sub_pre[hIndex].func; - preHookFunc(entry, t); + preHookFunc(&entry, &t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46849,11 +47020,11 @@ bool HP_mob_readdb_mobavail(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_readdb_mobavail_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_mobavail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_readdb_mobavail_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46864,10 +47035,10 @@ bool HP_mob_readdb_mobavail(char *str[], int columns, int current) { retVal___ = HPMHooks.source.mob.readdb_mobavail(str, columns, current); } if( HPMHooks.count.HP_mob_readdb_mobavail_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_mobavail_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_readdb_mobavail_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -46903,11 +47074,11 @@ bool HP_mob_parse_row_chatdb(char **str, const char *source, int line, int *last int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_parse_row_chatdb_pre ) { - bool (*preHookFunc) (char **str, const char *source, int *line, int *last_msg_id); + bool (*preHookFunc) (char ***str, const char **source, int *line, int **last_msg_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_chatdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_parse_row_chatdb_pre[hIndex].func; - retVal___ = preHookFunc(str, source, &line, last_msg_id); + retVal___ = preHookFunc(&str, &source, &line, &last_msg_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46918,10 +47089,10 @@ bool HP_mob_parse_row_chatdb(char **str, const char *source, int line, int *last retVal___ = HPMHooks.source.mob.parse_row_chatdb(str, source, line, last_msg_id); } if( HPMHooks.count.HP_mob_parse_row_chatdb_post ) { - bool (*postHookFunc) (bool retVal___, char **str, const char *source, int *line, int *last_msg_id); + bool (*postHookFunc) (bool retVal___, char **str, const char *source, int line, int *last_msg_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_chatdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_parse_row_chatdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, source, &line, last_msg_id); + retVal___ = postHookFunc(retVal___, str, source, line, last_msg_id); } } return retVal___; @@ -46956,11 +47127,11 @@ bool HP_mob_parse_row_mobskilldb(char **str, int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_parse_row_mobskilldb_pre ) { - bool (*preHookFunc) (char **str, int *columns, int *current); + bool (*preHookFunc) (char ***str, int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_mobskilldb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_parse_row_mobskilldb_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -46971,10 +47142,10 @@ bool HP_mob_parse_row_mobskilldb(char **str, int columns, int current) { retVal___ = HPMHooks.source.mob.parse_row_mobskilldb(str, columns, current); } if( HPMHooks.count.HP_mob_parse_row_mobskilldb_post ) { - bool (*postHookFunc) (bool retVal___, char **str, int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char **str, int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_mobskilldb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_parse_row_mobskilldb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -47009,11 +47180,11 @@ bool HP_mob_readdb_race2(char *fields[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_readdb_race2_pre ) { - bool (*preHookFunc) (char *fields[], int *columns, int *current); + bool (*preHookFunc) (char **fields[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_race2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_readdb_race2_pre[hIndex].func; - retVal___ = preHookFunc(fields, &columns, ¤t); + retVal___ = preHookFunc(&fields, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47024,10 +47195,10 @@ bool HP_mob_readdb_race2(char *fields[], int columns, int current) { retVal___ = HPMHooks.source.mob.readdb_race2(fields, columns, current); } if( HPMHooks.count.HP_mob_readdb_race2_post ) { - bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_race2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_readdb_race2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, fields, &columns, ¤t); + retVal___ = postHookFunc(retVal___, fields, columns, current); } } return retVal___; @@ -47036,11 +47207,11 @@ bool HP_mob_readdb_itemratio(char *str[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_mob_readdb_itemratio_pre ) { - bool (*preHookFunc) (char *str[], int *columns, int *current); + bool (*preHookFunc) (char **str[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_itemratio_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_mob_readdb_itemratio_pre[hIndex].func; - retVal___ = preHookFunc(str, &columns, ¤t); + retVal___ = preHookFunc(&str, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47051,10 +47222,10 @@ bool HP_mob_readdb_itemratio(char *str[], int columns, int current) { retVal___ = HPMHooks.source.mob.readdb_itemratio(str, columns, current); } if( HPMHooks.count.HP_mob_readdb_itemratio_post ) { - bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_itemratio_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_readdb_itemratio_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &columns, ¤t); + retVal___ = postHookFunc(retVal___, str, columns, current); } } return retVal___; @@ -47077,10 +47248,10 @@ void HP_mob_load(bool minimal) { HPMHooks.source.mob.load(minimal); } if( HPMHooks.count.HP_mob_load_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -47129,10 +47300,10 @@ void HP_mob_destroy_mob_db(int index) { HPMHooks.source.mob.destroy_mob_db(index); } if( HPMHooks.count.HP_mob_destroy_mob_db_post ) { - void (*postHookFunc) (int *index); + void (*postHookFunc) (int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_destroy_mob_db_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_mob_destroy_mob_db_post[hIndex].func; - postHookFunc(&index); + postHookFunc(index); } } return; @@ -47142,12 +47313,12 @@ int HP_npc_chat_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_chat_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_chat_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -47174,11 +47345,11 @@ int HP_npc_chat_sub(struct block_list *bl, va_list ap) { void HP_npc_chat_finalize(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_finalize_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_finalize_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47200,11 +47371,11 @@ void HP_npc_chat_finalize(struct npc_data *nd) { void HP_npc_chat_def_pattern(struct npc_data *nd, int setid, const char *pattern, const char *label) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_def_pattern_pre ) { - void (*preHookFunc) (struct npc_data *nd, int *setid, const char *pattern, const char *label); + void (*preHookFunc) (struct npc_data **nd, int *setid, const char **pattern, const char **label); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_def_pattern_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_def_pattern_pre[hIndex].func; - preHookFunc(nd, &setid, pattern, label); + preHookFunc(&nd, &setid, &pattern, &label); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47215,10 +47386,10 @@ void HP_npc_chat_def_pattern(struct npc_data *nd, int setid, const char *pattern HPMHooks.source.npc_chat.def_pattern(nd, setid, pattern, label); } if( HPMHooks.count.HP_npc_chat_def_pattern_post ) { - void (*postHookFunc) (struct npc_data *nd, int *setid, const char *pattern, const char *label); + void (*postHookFunc) (struct npc_data *nd, int setid, const char *pattern, const char *label); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_def_pattern_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_chat_def_pattern_post[hIndex].func; - postHookFunc(nd, &setid, pattern, label); + postHookFunc(nd, setid, pattern, label); } } return; @@ -47227,11 +47398,11 @@ struct pcrematch_entry* HP_npc_chat_create_pcrematch_entry(struct pcrematch_set int hIndex = 0; struct pcrematch_entry* retVal___ = NULL; if( HPMHooks.count.HP_npc_chat_create_pcrematch_entry_pre ) { - struct pcrematch_entry* (*preHookFunc) (struct pcrematch_set *set); + struct pcrematch_entry* (*preHookFunc) (struct pcrematch_set **set); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_create_pcrematch_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_create_pcrematch_entry_pre[hIndex].func; - retVal___ = preHookFunc(set); + retVal___ = preHookFunc(&set); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47253,11 +47424,11 @@ struct pcrematch_entry* HP_npc_chat_create_pcrematch_entry(struct pcrematch_set void HP_npc_chat_delete_pcreset(struct npc_data *nd, int setid) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_delete_pcreset_pre ) { - void (*preHookFunc) (struct npc_data *nd, int *setid); + void (*preHookFunc) (struct npc_data **nd, int *setid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_delete_pcreset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_delete_pcreset_pre[hIndex].func; - preHookFunc(nd, &setid); + preHookFunc(&nd, &setid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47268,10 +47439,10 @@ void HP_npc_chat_delete_pcreset(struct npc_data *nd, int setid) { HPMHooks.source.npc_chat.delete_pcreset(nd, setid); } if( HPMHooks.count.HP_npc_chat_delete_pcreset_post ) { - void (*postHookFunc) (struct npc_data *nd, int *setid); + void (*postHookFunc) (struct npc_data *nd, int setid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_delete_pcreset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_chat_delete_pcreset_post[hIndex].func; - postHookFunc(nd, &setid); + postHookFunc(nd, setid); } } return; @@ -47279,11 +47450,11 @@ void HP_npc_chat_delete_pcreset(struct npc_data *nd, int setid) { void HP_npc_chat_deactivate_pcreset(struct npc_data *nd, int setid) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_deactivate_pcreset_pre ) { - void (*preHookFunc) (struct npc_data *nd, int *setid); + void (*preHookFunc) (struct npc_data **nd, int *setid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_deactivate_pcreset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_deactivate_pcreset_pre[hIndex].func; - preHookFunc(nd, &setid); + preHookFunc(&nd, &setid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47294,10 +47465,10 @@ void HP_npc_chat_deactivate_pcreset(struct npc_data *nd, int setid) { HPMHooks.source.npc_chat.deactivate_pcreset(nd, setid); } if( HPMHooks.count.HP_npc_chat_deactivate_pcreset_post ) { - void (*postHookFunc) (struct npc_data *nd, int *setid); + void (*postHookFunc) (struct npc_data *nd, int setid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_deactivate_pcreset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_chat_deactivate_pcreset_post[hIndex].func; - postHookFunc(nd, &setid); + postHookFunc(nd, setid); } } return; @@ -47305,11 +47476,11 @@ void HP_npc_chat_deactivate_pcreset(struct npc_data *nd, int setid) { void HP_npc_chat_activate_pcreset(struct npc_data *nd, int setid) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_activate_pcreset_pre ) { - void (*preHookFunc) (struct npc_data *nd, int *setid); + void (*preHookFunc) (struct npc_data **nd, int *setid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_activate_pcreset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_activate_pcreset_pre[hIndex].func; - preHookFunc(nd, &setid); + preHookFunc(&nd, &setid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47320,10 +47491,10 @@ void HP_npc_chat_activate_pcreset(struct npc_data *nd, int setid) { HPMHooks.source.npc_chat.activate_pcreset(nd, setid); } if( HPMHooks.count.HP_npc_chat_activate_pcreset_post ) { - void (*postHookFunc) (struct npc_data *nd, int *setid); + void (*postHookFunc) (struct npc_data *nd, int setid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_activate_pcreset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_chat_activate_pcreset_post[hIndex].func; - postHookFunc(nd, &setid); + postHookFunc(nd, setid); } } return; @@ -47332,11 +47503,11 @@ struct pcrematch_set* HP_npc_chat_lookup_pcreset(struct npc_data *nd, int setid) int hIndex = 0; struct pcrematch_set* retVal___ = NULL; if( HPMHooks.count.HP_npc_chat_lookup_pcreset_pre ) { - struct pcrematch_set* (*preHookFunc) (struct npc_data *nd, int *setid); + struct pcrematch_set* (*preHookFunc) (struct npc_data **nd, int *setid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_lookup_pcreset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_lookup_pcreset_pre[hIndex].func; - retVal___ = preHookFunc(nd, &setid); + retVal___ = preHookFunc(&nd, &setid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47347,10 +47518,10 @@ struct pcrematch_set* HP_npc_chat_lookup_pcreset(struct npc_data *nd, int setid) retVal___ = HPMHooks.source.npc_chat.lookup_pcreset(nd, setid); } if( HPMHooks.count.HP_npc_chat_lookup_pcreset_post ) { - struct pcrematch_set* (*postHookFunc) (struct pcrematch_set* retVal___, struct npc_data *nd, int *setid); + struct pcrematch_set* (*postHookFunc) (struct pcrematch_set* retVal___, struct npc_data *nd, int setid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_lookup_pcreset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_chat_lookup_pcreset_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &setid); + retVal___ = postHookFunc(retVal___, nd, setid); } } return retVal___; @@ -47358,11 +47529,11 @@ struct pcrematch_set* HP_npc_chat_lookup_pcreset(struct npc_data *nd, int setid) void HP_npc_chat_finalize_pcrematch_entry(struct pcrematch_entry *e) { int hIndex = 0; if( HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_pre ) { - void (*preHookFunc) (struct pcrematch_entry *e); + void (*preHookFunc) (struct pcrematch_entry **e); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_chat_finalize_pcrematch_entry_pre[hIndex].func; - preHookFunc(e); + preHookFunc(&e); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47401,10 +47572,10 @@ int HP_npc_init(bool minimal) { retVal___ = HPMHooks.source.npc.init(minimal); } if( HPMHooks.count.HP_npc_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -47482,10 +47653,10 @@ struct view_data* HP_npc_get_viewdata(int class_) { retVal___ = HPMHooks.source.npc.get_viewdata(class_); } if( HPMHooks.count.HP_npc_get_viewdata_post ) { - struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_); + struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_get_viewdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -47494,12 +47665,12 @@ int HP_npc_isnear_sub(struct block_list *bl, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_isnear_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list args); + int (*preHookFunc) (struct block_list **bl, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_npc_isnear_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, args___copy); + retVal___ = preHookFunc(&bl, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -47527,11 +47698,11 @@ bool HP_npc_isnear(struct block_list *bl) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_isnear_pre ) { - bool (*preHookFunc) (struct block_list *bl); + bool (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_isnear_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47554,11 +47725,11 @@ int HP_npc_ontouch_event(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_ontouch_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_ontouch_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, nd); + retVal___ = preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47581,11 +47752,11 @@ int HP_npc_ontouch2_event(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_ontouch2_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch2_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_ontouch2_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, nd); + retVal___ = preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47608,11 +47779,11 @@ int HP_npc_onuntouch_event(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_onuntouch_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_onuntouch_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_onuntouch_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, nd); + retVal___ = preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47635,12 +47806,12 @@ int HP_npc_enable_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_enable_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_enable_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -47668,11 +47839,11 @@ int HP_npc_enable(const char *name, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_enable_pre ) { - int (*preHookFunc) (const char *name, int *flag); + int (*preHookFunc) (const char **name, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_enable_pre[hIndex].func; - retVal___ = preHookFunc(name, &flag); + retVal___ = preHookFunc(&name, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47683,10 +47854,10 @@ int HP_npc_enable(const char *name, int flag) { retVal___ = HPMHooks.source.npc.enable(name, flag); } if( HPMHooks.count.HP_npc_enable_post ) { - int (*postHookFunc) (int retVal___, const char *name, int *flag); + int (*postHookFunc) (int retVal___, const char *name, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_enable_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &flag); + retVal___ = postHookFunc(retVal___, name, flag); } } return retVal___; @@ -47695,11 +47866,11 @@ struct npc_data* HP_npc_name2id(const char *name) { int hIndex = 0; struct npc_data* retVal___ = NULL; if( HPMHooks.count.HP_npc_name2id_pre ) { - struct npc_data* (*preHookFunc) (const char *name); + struct npc_data* (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_name2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_name2id_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47722,11 +47893,11 @@ int HP_npc_event_dequeue(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_dequeue_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_dequeue_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_dequeue_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47747,8 +47918,7 @@ int HP_npc_event_dequeue(struct map_session_data *sd) { } struct DBData HP_npc_event_export_create(union DBKey key, va_list args) { int hIndex = 0; - struct DBData retVal___; - memset(&retVal___, '\0', sizeof(struct DBData)); + struct DBData retVal___ = { 0 }; if( HPMHooks.count.HP_npc_event_export_create_pre ) { struct DBData (*preHookFunc) (union DBKey *key, va_list args); *HPMforce_return = false; @@ -47769,11 +47939,11 @@ struct DBData HP_npc_event_export_create(union DBKey key, va_list args) { va_end(args___copy); } if( HPMHooks.count.HP_npc_event_export_create_post ) { - struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey *key, va_list args); + struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_create_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_npc_event_export_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, args___copy); + retVal___ = postHookFunc(retVal___, key, args___copy); va_end(args___copy); } } @@ -47783,11 +47953,11 @@ int HP_npc_event_export(struct npc_data *nd, int i) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_export_pre ) { - int (*preHookFunc) (struct npc_data *nd, int *i); + int (*preHookFunc) (struct npc_data **nd, int *i); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_export_pre[hIndex].func; - retVal___ = preHookFunc(nd, &i); + retVal___ = preHookFunc(&nd, &i); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47798,10 +47968,10 @@ int HP_npc_event_export(struct npc_data *nd, int i) { retVal___ = HPMHooks.source.npc.event_export(nd, i); } if( HPMHooks.count.HP_npc_event_export_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, int *i); + int (*postHookFunc) (int retVal___, struct npc_data *nd, int i); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_event_export_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &i); + retVal___ = postHookFunc(retVal___, nd, i); } } return retVal___; @@ -47810,11 +47980,11 @@ int HP_npc_event_sub(struct map_session_data *sd, struct event_data *ev, const c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct event_data *ev, const char *eventname); + int (*preHookFunc) (struct map_session_data **sd, struct event_data **ev, const char **eventname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, ev, eventname); + retVal___ = preHookFunc(&sd, &ev, &eventname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47836,12 +48006,12 @@ int HP_npc_event_sub(struct map_session_data *sd, struct event_data *ev, const c void HP_npc_event_doall_sub(void *key, void *data, va_list ap) { int hIndex = 0; if( HPMHooks.count.HP_npc_event_doall_sub_pre ) { - void (*preHookFunc) (void *key, void *data, va_list ap); + void (*preHookFunc) (void **key, void **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_event_doall_sub_pre[hIndex].func; - preHookFunc(key, data, ap___copy); + preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -47869,11 +48039,11 @@ int HP_npc_event_do(const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_do_pre ) { - int (*preHookFunc) (const char *name); + int (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_do_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47896,11 +48066,11 @@ int HP_npc_event_doall_id(const char *name, int rid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_doall_id_pre ) { - int (*preHookFunc) (const char *name, int *rid); + int (*preHookFunc) (const char **name, int *rid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_doall_id_pre[hIndex].func; - retVal___ = preHookFunc(name, &rid); + retVal___ = preHookFunc(&name, &rid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47911,10 +48081,10 @@ int HP_npc_event_doall_id(const char *name, int rid) { retVal___ = HPMHooks.source.npc.event_doall_id(name, rid); } if( HPMHooks.count.HP_npc_event_doall_id_post ) { - int (*postHookFunc) (int retVal___, const char *name, int *rid); + int (*postHookFunc) (int retVal___, const char *name, int rid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_event_doall_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &rid); + retVal___ = postHookFunc(retVal___, name, rid); } } return retVal___; @@ -47923,11 +48093,11 @@ int HP_npc_event_doall(const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_doall_pre ) { - int (*preHookFunc) (const char *name); + int (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_doall_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -47965,10 +48135,10 @@ int HP_npc_event_do_clock(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.npc.event_do_clock(tid, tick, id, data); } if( HPMHooks.count.HP_npc_event_do_clock_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_clock_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_event_do_clock_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -47991,10 +48161,10 @@ void HP_npc_event_do_oninit(bool reload) { HPMHooks.source.npc.event_do_oninit(reload); } if( HPMHooks.count.HP_npc_event_do_oninit_post ) { - void (*postHookFunc) (bool *reload); + void (*postHookFunc) (bool reload); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_oninit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_event_do_oninit_post[hIndex].func; - postHookFunc(&reload); + postHookFunc(reload); } } return; @@ -48003,11 +48173,11 @@ int HP_npc_timerevent_export(struct npc_data *nd, int i) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_timerevent_export_pre ) { - int (*preHookFunc) (struct npc_data *nd, int *i); + int (*preHookFunc) (struct npc_data **nd, int *i); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_export_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_timerevent_export_pre[hIndex].func; - retVal___ = preHookFunc(nd, &i); + retVal___ = preHookFunc(&nd, &i); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48018,10 +48188,10 @@ int HP_npc_timerevent_export(struct npc_data *nd, int i) { retVal___ = HPMHooks.source.npc.timerevent_export(nd, i); } if( HPMHooks.count.HP_npc_timerevent_export_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, int *i); + int (*postHookFunc) (int retVal___, struct npc_data *nd, int i); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_export_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_timerevent_export_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &i); + retVal___ = postHookFunc(retVal___, nd, i); } } return retVal___; @@ -48045,10 +48215,10 @@ int HP_npc_timerevent(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.npc.timerevent(tid, tick, id, data); } if( HPMHooks.count.HP_npc_timerevent_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_timerevent_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -48057,11 +48227,11 @@ int HP_npc_timerevent_start(struct npc_data *nd, int rid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_timerevent_start_pre ) { - int (*preHookFunc) (struct npc_data *nd, int *rid); + int (*preHookFunc) (struct npc_data **nd, int *rid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_timerevent_start_pre[hIndex].func; - retVal___ = preHookFunc(nd, &rid); + retVal___ = preHookFunc(&nd, &rid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48072,10 +48242,10 @@ int HP_npc_timerevent_start(struct npc_data *nd, int rid) { retVal___ = HPMHooks.source.npc.timerevent_start(nd, rid); } if( HPMHooks.count.HP_npc_timerevent_start_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, int *rid); + int (*postHookFunc) (int retVal___, struct npc_data *nd, int rid); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_timerevent_start_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &rid); + retVal___ = postHookFunc(retVal___, nd, rid); } } return retVal___; @@ -48084,11 +48254,11 @@ int HP_npc_timerevent_stop(struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_timerevent_stop_pre ) { - int (*preHookFunc) (struct npc_data *nd); + int (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_stop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_timerevent_stop_pre[hIndex].func; - retVal___ = preHookFunc(nd); + retVal___ = preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48110,11 +48280,11 @@ int HP_npc_timerevent_stop(struct npc_data *nd) { void HP_npc_timerevent_quit(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_npc_timerevent_quit_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_quit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_timerevent_quit_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48137,11 +48307,11 @@ int64 HP_npc_gettimerevent_tick(struct npc_data *nd) { int hIndex = 0; int64 retVal___ = 0; if( HPMHooks.count.HP_npc_gettimerevent_tick_pre ) { - int64 (*preHookFunc) (struct npc_data *nd); + int64 (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_gettimerevent_tick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_gettimerevent_tick_pre[hIndex].func; - retVal___ = preHookFunc(nd); + retVal___ = preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48164,11 +48334,11 @@ int HP_npc_settimerevent_tick(struct npc_data *nd, int newtimer) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_settimerevent_tick_pre ) { - int (*preHookFunc) (struct npc_data *nd, int *newtimer); + int (*preHookFunc) (struct npc_data **nd, int *newtimer); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_settimerevent_tick_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_settimerevent_tick_pre[hIndex].func; - retVal___ = preHookFunc(nd, &newtimer); + retVal___ = preHookFunc(&nd, &newtimer); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48179,10 +48349,10 @@ int HP_npc_settimerevent_tick(struct npc_data *nd, int newtimer) { retVal___ = HPMHooks.source.npc.settimerevent_tick(nd, newtimer); } if( HPMHooks.count.HP_npc_settimerevent_tick_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, int *newtimer); + int (*postHookFunc) (int retVal___, struct npc_data *nd, int newtimer); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_settimerevent_tick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_settimerevent_tick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &newtimer); + retVal___ = postHookFunc(retVal___, nd, newtimer); } } return retVal___; @@ -48191,11 +48361,11 @@ int HP_npc_event(struct map_session_data *sd, const char *eventname, int ontouch int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *eventname, int *ontouch); + int (*preHookFunc) (struct map_session_data **sd, const char **eventname, int *ontouch); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, eventname, &ontouch); + retVal___ = preHookFunc(&sd, &eventname, &ontouch); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48206,10 +48376,10 @@ int HP_npc_event(struct map_session_data *sd, const char *eventname, int ontouch retVal___ = HPMHooks.source.npc.event(sd, eventname, ontouch); } if( HPMHooks.count.HP_npc_event_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *eventname, int *ontouch); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *eventname, int ontouch); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_event_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, eventname, &ontouch); + retVal___ = postHookFunc(retVal___, sd, eventname, ontouch); } } return retVal___; @@ -48218,12 +48388,12 @@ int HP_npc_touch_areanpc_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_touch_areanpc_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_touch_areanpc_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -48251,11 +48421,11 @@ int HP_npc_touchnext_areanpc(struct map_session_data *sd, bool leavemap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_touchnext_areanpc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, bool *leavemap); + int (*preHookFunc) (struct map_session_data **sd, bool *leavemap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touchnext_areanpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_touchnext_areanpc_pre[hIndex].func; - retVal___ = preHookFunc(sd, &leavemap); + retVal___ = preHookFunc(&sd, &leavemap); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48266,10 +48436,10 @@ int HP_npc_touchnext_areanpc(struct map_session_data *sd, bool leavemap) { retVal___ = HPMHooks.source.npc.touchnext_areanpc(sd, leavemap); } if( HPMHooks.count.HP_npc_touchnext_areanpc_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *leavemap); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool leavemap); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touchnext_areanpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_touchnext_areanpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &leavemap); + retVal___ = postHookFunc(retVal___, sd, leavemap); } } return retVal___; @@ -48278,11 +48448,11 @@ int HP_npc_touch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_touch_areanpc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y); + int (*preHookFunc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_touch_areanpc_pre[hIndex].func; - retVal___ = preHookFunc(sd, &m, &x, &y); + retVal___ = preHookFunc(&sd, &m, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48293,10 +48463,10 @@ int HP_npc_touch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y) retVal___ = HPMHooks.source.npc.touch_areanpc(sd, m, x, y); } if( HPMHooks.count.HP_npc_touch_areanpc_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_touch_areanpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &m, &x, &y); + retVal___ = postHookFunc(retVal___, sd, m, x, y); } } return retVal___; @@ -48305,11 +48475,11 @@ int HP_npc_untouch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_untouch_areanpc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y); + int (*preHookFunc) (struct map_session_data **sd, int16 *m, int16 *x, int16 *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_untouch_areanpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_untouch_areanpc_pre[hIndex].func; - retVal___ = preHookFunc(sd, &m, &x, &y); + retVal___ = preHookFunc(&sd, &m, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48320,10 +48490,10 @@ int HP_npc_untouch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 retVal___ = HPMHooks.source.npc.untouch_areanpc(sd, m, x, y); } if( HPMHooks.count.HP_npc_untouch_areanpc_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_untouch_areanpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_untouch_areanpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &m, &x, &y); + retVal___ = postHookFunc(retVal___, sd, m, x, y); } } return retVal___; @@ -48332,11 +48502,11 @@ int HP_npc_touch_areanpc2(struct mob_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_touch_areanpc2_pre ) { - int (*preHookFunc) (struct mob_data *md); + int (*preHookFunc) (struct mob_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_touch_areanpc2_pre[hIndex].func; - retVal___ = preHookFunc(md); + retVal___ = preHookFunc(&md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48374,10 +48544,10 @@ int HP_npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range) { retVal___ = HPMHooks.source.npc.check_areanpc(flag, m, x, y, range); } if( HPMHooks.count.HP_npc_check_areanpc_post ) { - int (*postHookFunc) (int retVal___, int *flag, int16 *m, int16 *x, int16 *y, int16 *range); + int (*postHookFunc) (int retVal___, int flag, int16 m, int16 x, int16 y, int16 range); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_check_areanpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_check_areanpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &flag, &m, &x, &y, &range); + retVal___ = postHookFunc(retVal___, flag, m, x, y, range); } } return retVal___; @@ -48386,11 +48556,11 @@ struct npc_data* HP_npc_checknear(struct map_session_data *sd, struct block_list int hIndex = 0; struct npc_data* retVal___ = NULL; if( HPMHooks.count.HP_npc_checknear_pre ) { - struct npc_data* (*preHookFunc) (struct map_session_data *sd, struct block_list *bl); + struct npc_data* (*preHookFunc) (struct map_session_data **sd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_checknear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_checknear_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl); + retVal___ = preHookFunc(&sd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48413,11 +48583,11 @@ int HP_npc_globalmessage(const char *name, const char *mes) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_globalmessage_pre ) { - int (*preHookFunc) (const char *name, const char *mes); + int (*preHookFunc) (const char **name, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_globalmessage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_globalmessage_pre[hIndex].func; - retVal___ = preHookFunc(name, mes); + retVal___ = preHookFunc(&name, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48439,11 +48609,11 @@ int HP_npc_globalmessage(const char *name, const char *mes) { void HP_npc_run_tomb(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_run_tomb_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_run_tomb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_run_tomb_pre[hIndex].func; - preHookFunc(sd, nd); + preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48466,11 +48636,11 @@ int HP_npc_click(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_click_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_click_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_click_pre[hIndex].func; - retVal___ = preHookFunc(sd, nd); + retVal___ = preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48493,11 +48663,11 @@ int HP_npc_scriptcont(struct map_session_data *sd, int id, bool closing) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_scriptcont_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *id, bool *closing); + int (*preHookFunc) (struct map_session_data **sd, int *id, bool *closing); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_scriptcont_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_scriptcont_pre[hIndex].func; - retVal___ = preHookFunc(sd, &id, &closing); + retVal___ = preHookFunc(&sd, &id, &closing); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48508,10 +48678,10 @@ int HP_npc_scriptcont(struct map_session_data *sd, int id, bool closing) { retVal___ = HPMHooks.source.npc.scriptcont(sd, id, closing); } if( HPMHooks.count.HP_npc_scriptcont_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, bool *closing); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, bool closing); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_scriptcont_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_scriptcont_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &id, &closing); + retVal___ = postHookFunc(retVal___, sd, id, closing); } } return retVal___; @@ -48520,11 +48690,11 @@ int HP_npc_buysellsel(struct map_session_data *sd, int id, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_buysellsel_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *id, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *id, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buysellsel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_buysellsel_pre[hIndex].func; - retVal___ = preHookFunc(sd, &id, &type); + retVal___ = preHookFunc(&sd, &id, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48535,10 +48705,10 @@ int HP_npc_buysellsel(struct map_session_data *sd, int id, int type) { retVal___ = HPMHooks.source.npc.buysellsel(sd, id, type); } if( HPMHooks.count.HP_npc_buysellsel_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buysellsel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_buysellsel_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &id, &type); + retVal___ = postHookFunc(retVal___, sd, id, type); } } return retVal___; @@ -48547,11 +48717,11 @@ int HP_npc_cashshop_buylist(struct map_session_data *sd, int points, struct item int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_cashshop_buylist_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *points, struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, int *points, struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buylist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_cashshop_buylist_pre[hIndex].func; - retVal___ = preHookFunc(sd, &points, item_list); + retVal___ = preHookFunc(&sd, &points, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48562,10 +48732,10 @@ int HP_npc_cashshop_buylist(struct map_session_data *sd, int points, struct item retVal___ = HPMHooks.source.npc.cashshop_buylist(sd, points, item_list); } if( HPMHooks.count.HP_npc_cashshop_buylist_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *points, struct itemlist *item_list); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int points, struct itemlist *item_list); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buylist_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_cashshop_buylist_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &points, item_list); + retVal___ = postHookFunc(retVal___, sd, points, item_list); } } return retVal___; @@ -48574,11 +48744,11 @@ int HP_npc_buylist_sub(struct map_session_data *sd, struct itemlist *item_list, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_buylist_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_buylist_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list, nd); + retVal___ = preHookFunc(&sd, &item_list, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48601,11 +48771,11 @@ int HP_npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_cashshop_buy_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount, int *points); + int (*preHookFunc) (struct map_session_data **sd, int *nameid, int *amount, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_cashshop_buy_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid, &amount, &points); + retVal___ = preHookFunc(&sd, &nameid, &amount, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48616,10 +48786,10 @@ int HP_npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int retVal___ = HPMHooks.source.npc.cashshop_buy(sd, nameid, amount, points); } if( HPMHooks.count.HP_npc_cashshop_buy_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *amount, int *points); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int amount, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_cashshop_buy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid, &amount, &points); + retVal___ = postHookFunc(retVal___, sd, nameid, amount, points); } } return retVal___; @@ -48628,11 +48798,11 @@ int HP_npc_buylist(struct map_session_data *sd, struct itemlist *item_list) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_buylist_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_buylist_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list); + retVal___ = preHookFunc(&sd, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48655,11 +48825,11 @@ int HP_npc_selllist_sub(struct map_session_data *sd, struct itemlist *item_list, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_selllist_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd); + int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_selllist_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list, nd); + retVal___ = preHookFunc(&sd, &item_list, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48682,11 +48852,11 @@ int HP_npc_selllist(struct map_session_data *sd, struct itemlist *item_list) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_selllist_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_selllist_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list); + retVal___ = preHookFunc(&sd, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48709,11 +48879,11 @@ int HP_npc_remove_map(struct npc_data *nd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_remove_map_pre ) { - int (*preHookFunc) (struct npc_data *nd); + int (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_remove_map_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_remove_map_pre[hIndex].func; - retVal___ = preHookFunc(nd); + retVal___ = preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48736,12 +48906,12 @@ int HP_npc_unload_ev(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_unload_ev_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_unload_ev_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -48755,11 +48925,11 @@ int HP_npc_unload_ev(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_npc_unload_ev_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_npc_unload_ev_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -48769,12 +48939,12 @@ int HP_npc_unload_ev_label(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_unload_ev_label_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_label_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_unload_ev_label_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -48788,11 +48958,11 @@ int HP_npc_unload_ev_label(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_npc_unload_ev_label_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_label_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_npc_unload_ev_label_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -48802,12 +48972,12 @@ int HP_npc_unload_dup_sub(struct npc_data *nd, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_unload_dup_sub_pre ) { - int (*preHookFunc) (struct npc_data *nd, va_list args); + int (*preHookFunc) (struct npc_data **nd, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_dup_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_npc_unload_dup_sub_pre[hIndex].func; - retVal___ = preHookFunc(nd, args___copy); + retVal___ = preHookFunc(&nd, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -48834,11 +49004,11 @@ int HP_npc_unload_dup_sub(struct npc_data *nd, va_list args) { void HP_npc_unload_duplicates(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_unload_duplicates_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_duplicates_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_unload_duplicates_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48861,11 +49031,11 @@ int HP_npc_unload(struct npc_data *nd, bool single) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_unload_pre ) { - int (*preHookFunc) (struct npc_data *nd, bool *single); + int (*preHookFunc) (struct npc_data **nd, bool *single); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_unload_pre[hIndex].func; - retVal___ = preHookFunc(nd, &single); + retVal___ = preHookFunc(&nd, &single); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48876,10 +49046,10 @@ int HP_npc_unload(struct npc_data *nd, bool single) { retVal___ = HPMHooks.source.npc.unload(nd, single); } if( HPMHooks.count.HP_npc_unload_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, bool *single); + int (*postHookFunc) (int retVal___, struct npc_data *nd, bool single); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_unload_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, &single); + retVal___ = postHookFunc(retVal___, nd, single); } } return retVal___; @@ -48913,11 +49083,11 @@ void HP_npc_clearsrcfile(void) { void HP_npc_addsrcfile(const char *name) { int hIndex = 0; if( HPMHooks.count.HP_npc_addsrcfile_pre ) { - void (*preHookFunc) (const char *name); + void (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_addsrcfile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_addsrcfile_pre[hIndex].func; - preHookFunc(name); + preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48939,11 +49109,11 @@ void HP_npc_addsrcfile(const char *name) { void HP_npc_delsrcfile(const char *name) { int hIndex = 0; if( HPMHooks.count.HP_npc_delsrcfile_pre ) { - void (*preHookFunc) (const char *name); + void (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_delsrcfile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_delsrcfile_pre[hIndex].func; - preHookFunc(name); + preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48966,11 +49136,11 @@ const char* HP_npc_retainpathreference(const char *filepath) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_retainpathreference_pre ) { - const char* (*preHookFunc) (const char *filepath); + const char* (*preHookFunc) (const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_retainpathreference_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_retainpathreference_pre[hIndex].func; - retVal___ = preHookFunc(filepath); + retVal___ = preHookFunc(&filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -48992,11 +49162,11 @@ const char* HP_npc_retainpathreference(const char *filepath) { void HP_npc_releasepathreference(const char *filepath) { int hIndex = 0; if( HPMHooks.count.HP_npc_releasepathreference_pre ) { - void (*preHookFunc) (const char *filepath); + void (*preHookFunc) (const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_releasepathreference_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_releasepathreference_pre[hIndex].func; - preHookFunc(filepath); + preHookFunc(&filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49018,11 +49188,11 @@ void HP_npc_releasepathreference(const char *filepath) { void HP_npc_parsename(struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath) { int hIndex = 0; if( HPMHooks.count.HP_npc_parsename_pre ) { - void (*preHookFunc) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath); + void (*preHookFunc) (struct npc_data **nd, const char **name, const char **start, const char **buffer, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsename_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parsename_pre[hIndex].func; - preHookFunc(nd, name, start, buffer, filepath); + preHookFunc(&nd, &name, &start, &buffer, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49045,11 +49215,11 @@ int HP_npc_parseview(const char *w4, const char *start, const char *buffer, cons 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); + int (*preHookFunc) (const char **w4, const char **start, const char **buffer, const char **filepath); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&w4, &start, &buffer, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49072,11 +49242,11 @@ 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); + bool (*preHookFunc) (const char **viewid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_viewisid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_viewisid_pre[hIndex].func; - retVal___ = preHookFunc(viewid); + retVal___ = preHookFunc(&viewid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49114,10 +49284,10 @@ struct npc_data* HP_npc_create_npc(enum npc_subtype subtype, int m, int x, int y retVal___ = HPMHooks.source.npc.create_npc(subtype, m, x, y, dir, class_); } if( HPMHooks.count.HP_npc_create_npc_post ) { - struct npc_data* (*postHookFunc) (struct npc_data* retVal___, enum npc_subtype *subtype, int *m, int *x, int *y, uint8 *dir, int16 *class_); + struct npc_data* (*postHookFunc) (struct npc_data* retVal___, enum npc_subtype subtype, int m, int x, int y, uint8 dir, int16 class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_create_npc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_create_npc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &subtype, &m, &x, &y, &dir, &class_); + retVal___ = postHookFunc(retVal___, subtype, m, x, y, dir, class_); } } return retVal___; @@ -49126,11 +49296,11 @@ struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, sho int hIndex = 0; struct npc_data* retVal___ = NULL; if( HPMHooks.count.HP_npc_add_warp_pre ) { - struct npc_data* (*preHookFunc) (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); + struct npc_data* (*preHookFunc) (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); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_warp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_add_warp_pre[hIndex].func; - retVal___ = preHookFunc(name, &from_mapid, &from_x, &from_y, &xs, &ys, &to_mapindex, &to_x, &to_y); + retVal___ = preHookFunc(&name, &from_mapid, &from_x, &from_y, &xs, &ys, &to_mapindex, &to_x, &to_y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49141,10 +49311,10 @@ struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, sho retVal___ = HPMHooks.source.npc.add_warp(name, from_mapid, from_x, from_y, xs, ys, to_mapindex, to_x, to_y); } if( HPMHooks.count.HP_npc_add_warp_post ) { - struct npc_data* (*postHookFunc) (struct npc_data* retVal___, 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); + struct npc_data* (*postHookFunc) (struct npc_data* retVal___, 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); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_warp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_add_warp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, &from_mapid, &from_x, &from_y, &xs, &ys, &to_mapindex, &to_x, &to_y); + retVal___ = postHookFunc(retVal___, name, from_mapid, from_x, from_y, xs, ys, to_mapindex, to_x, to_y); } } return retVal___; @@ -49153,11 +49323,11 @@ const char* HP_npc_parse_warp(const char *w1, const char *w2, const char *w3, co int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_warp_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_warp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_warp_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49180,11 +49350,11 @@ const char* HP_npc_parse_shop(const char *w1, const char *w2, const char *w3, co int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_shop_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_shop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_shop_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49207,11 +49377,11 @@ const char* HP_npc_parse_unknown_object(const char *w1, const char *w2, const ch int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_unknown_object_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_object_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_unknown_object_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49233,11 +49403,11 @@ const char* HP_npc_parse_unknown_object(const char *w1, const char *w2, const ch void HP_npc_convertlabel_db(struct npc_label_list *label_list, const char *filepath) { int hIndex = 0; if( HPMHooks.count.HP_npc_convertlabel_db_pre ) { - void (*preHookFunc) (struct npc_label_list *label_list, const char *filepath); + void (*preHookFunc) (struct npc_label_list **label_list, const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_convertlabel_db_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_convertlabel_db_pre[hIndex].func; - preHookFunc(label_list, filepath); + preHookFunc(&label_list, &filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49260,11 +49430,11 @@ const char* HP_npc_skip_script(const char *start, const char *buffer, const char int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_skip_script_pre ) { - const char* (*preHookFunc) (const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_skip_script_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_skip_script_pre[hIndex].func; - retVal___ = preHookFunc(start, buffer, filepath, retval); + retVal___ = preHookFunc(&start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49287,11 +49457,11 @@ const char* HP_npc_parse_script(const char *w1, const char *w2, const char *w3, int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_script_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *options, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_script_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_script_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, &options, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &options, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49302,10 +49472,10 @@ const char* HP_npc_parse_script(const char *w1, const char *w2, const char *w3, retVal___ = HPMHooks.source.npc.parse_script(w1, w2, w3, w4, start, buffer, filepath, options, retval); } if( HPMHooks.count.HP_npc_parse_script_post ) { - const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *options, int *retval); + const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_script_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_parse_script_post[hIndex].func; - retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, &options, retval); + retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, options, retval); } } return retVal___; @@ -49313,11 +49483,11 @@ const char* HP_npc_parse_script(const char *w1, const char *w2, const char *w3, void HP_npc_add_to_location(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_add_to_location_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_to_location_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_add_to_location_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49340,11 +49510,11 @@ bool HP_npc_duplicate_script_sub(struct npc_data *nd, const struct npc_data *snd int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_duplicate_script_sub_pre ) { - bool (*preHookFunc) (struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_script_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_duplicate_script_sub_pre[hIndex].func; - retVal___ = preHookFunc(nd, snd, &xs, &ys, &options); + retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49355,10 +49525,10 @@ bool HP_npc_duplicate_script_sub(struct npc_data *nd, const struct npc_data *snd retVal___ = HPMHooks.source.npc.duplicate_script_sub(nd, snd, xs, ys, options); } if( HPMHooks.count.HP_npc_duplicate_script_sub_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_script_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_duplicate_script_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, snd, &xs, &ys, &options); + retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options); } } return retVal___; @@ -49367,11 +49537,11 @@ bool HP_npc_duplicate_shop_sub(struct npc_data *nd, const struct npc_data *snd, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_duplicate_shop_sub_pre ) { - bool (*preHookFunc) (struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_shop_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_duplicate_shop_sub_pre[hIndex].func; - retVal___ = preHookFunc(nd, snd, &xs, &ys, &options); + retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49382,10 +49552,10 @@ bool HP_npc_duplicate_shop_sub(struct npc_data *nd, const struct npc_data *snd, retVal___ = HPMHooks.source.npc.duplicate_shop_sub(nd, snd, xs, ys, options); } if( HPMHooks.count.HP_npc_duplicate_shop_sub_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_shop_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_duplicate_shop_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, snd, &xs, &ys, &options); + retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options); } } return retVal___; @@ -49394,11 +49564,11 @@ bool HP_npc_duplicate_warp_sub(struct npc_data *nd, const struct npc_data *snd, int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_duplicate_warp_sub_pre ) { - bool (*preHookFunc) (struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_warp_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_duplicate_warp_sub_pre[hIndex].func; - retVal___ = preHookFunc(nd, snd, &xs, &ys, &options); + retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49409,10 +49579,10 @@ bool HP_npc_duplicate_warp_sub(struct npc_data *nd, const struct npc_data *snd, retVal___ = HPMHooks.source.npc.duplicate_warp_sub(nd, snd, xs, ys, options); } if( HPMHooks.count.HP_npc_duplicate_warp_sub_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_warp_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_duplicate_warp_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, snd, &xs, &ys, &options); + retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options); } } return retVal___; @@ -49421,11 +49591,11 @@ bool HP_npc_duplicate_sub(struct npc_data *nd, const struct npc_data *snd, int x int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_duplicate_sub_pre ) { - bool (*preHookFunc) (struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_duplicate_sub_pre[hIndex].func; - retVal___ = preHookFunc(nd, snd, &xs, &ys, &options); + retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49436,10 +49606,10 @@ bool HP_npc_duplicate_sub(struct npc_data *nd, const struct npc_data *snd, int x retVal___ = HPMHooks.source.npc.duplicate_sub(nd, snd, xs, ys, options); } if( HPMHooks.count.HP_npc_duplicate_sub_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int *xs, int *ys, int *options); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_duplicate_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, snd, &xs, &ys, &options); + retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options); } } return retVal___; @@ -49448,11 +49618,11 @@ const char* HP_npc_parse_duplicate(const char *w1, const char *w2, const char *w int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_duplicate_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *options, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_duplicate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_duplicate_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, &options, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &options, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49463,10 +49633,10 @@ const char* HP_npc_parse_duplicate(const char *w1, const char *w2, const char *w retVal___ = HPMHooks.source.npc.parse_duplicate(w1, w2, w3, w4, start, buffer, filepath, options, retval); } if( HPMHooks.count.HP_npc_parse_duplicate_post ) { - const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *options, int *retval); + const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_duplicate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_parse_duplicate_post[hIndex].func; - retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, &options, retval); + retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, options, retval); } } return retVal___; @@ -49475,11 +49645,11 @@ int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_duplicate4instance_pre ) { - int (*preHookFunc) (struct npc_data *snd, int16 *m); + int (*preHookFunc) (struct npc_data **snd, int16 *m); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_duplicate4instance_pre[hIndex].func; - retVal___ = preHookFunc(snd, &m); + retVal___ = preHookFunc(&snd, &m); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49490,10 +49660,10 @@ int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) { retVal___ = HPMHooks.source.npc.duplicate4instance(snd, m); } if( HPMHooks.count.HP_npc_duplicate4instance_post ) { - int (*postHookFunc) (int retVal___, struct npc_data *snd, int16 *m); + int (*postHookFunc) (int retVal___, struct npc_data *snd, int16 m); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_duplicate4instance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, snd, &m); + retVal___ = postHookFunc(retVal___, snd, m); } } return retVal___; @@ -49501,11 +49671,11 @@ int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) { void HP_npc_setcells(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_setcells_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setcells_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_setcells_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49528,12 +49698,12 @@ int HP_npc_unsetcells_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_unsetcells_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_npc_unsetcells_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -49560,11 +49730,11 @@ int HP_npc_unsetcells_sub(struct block_list *bl, va_list ap) { void HP_npc_unsetcells(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_unsetcells_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_unsetcells_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49586,11 +49756,11 @@ void HP_npc_unsetcells(struct npc_data *nd) { void HP_npc_movenpc(struct npc_data *nd, int16 x, int16 y) { int hIndex = 0; if( HPMHooks.count.HP_npc_movenpc_pre ) { - void (*preHookFunc) (struct npc_data *nd, int16 *x, int16 *y); + void (*preHookFunc) (struct npc_data **nd, int16 *x, int16 *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_movenpc_pre[hIndex].func; - preHookFunc(nd, &x, &y); + preHookFunc(&nd, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49601,10 +49771,10 @@ void HP_npc_movenpc(struct npc_data *nd, int16 x, int16 y) { HPMHooks.source.npc.movenpc(nd, x, y); } if( HPMHooks.count.HP_npc_movenpc_post ) { - void (*postHookFunc) (struct npc_data *nd, int16 *x, int16 *y); + void (*postHookFunc) (struct npc_data *nd, int16 x, int16 y); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_movenpc_post[hIndex].func; - postHookFunc(nd, &x, &y); + postHookFunc(nd, x, y); } } return; @@ -49612,11 +49782,11 @@ void HP_npc_movenpc(struct npc_data *nd, int16 x, int16 y) { void HP_npc_setdisplayname(struct npc_data *nd, const char *newname) { int hIndex = 0; if( HPMHooks.count.HP_npc_setdisplayname_pre ) { - void (*preHookFunc) (struct npc_data *nd, const char *newname); + void (*preHookFunc) (struct npc_data **nd, const char **newname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setdisplayname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_setdisplayname_pre[hIndex].func; - preHookFunc(nd, newname); + preHookFunc(&nd, &newname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49638,11 +49808,11 @@ void HP_npc_setdisplayname(struct npc_data *nd, const char *newname) { void HP_npc_setclass(struct npc_data *nd, short class_) { int hIndex = 0; if( HPMHooks.count.HP_npc_setclass_pre ) { - void (*preHookFunc) (struct npc_data *nd, short *class_); + void (*preHookFunc) (struct npc_data **nd, short *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_setclass_pre[hIndex].func; - preHookFunc(nd, &class_); + preHookFunc(&nd, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49653,10 +49823,10 @@ void HP_npc_setclass(struct npc_data *nd, short class_) { HPMHooks.source.npc.setclass(nd, class_); } if( HPMHooks.count.HP_npc_setclass_post ) { - void (*postHookFunc) (struct npc_data *nd, short *class_); + void (*postHookFunc) (struct npc_data *nd, short class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_setclass_post[hIndex].func; - postHookFunc(nd, &class_); + postHookFunc(nd, class_); } } return; @@ -49665,11 +49835,11 @@ int HP_npc_do_atcmd_event(struct map_session_data *sd, const char *command, cons int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_do_atcmd_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *command, const char *message, const char *eventname); + int (*preHookFunc) (struct map_session_data **sd, const char **command, const char **message, const char **eventname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_atcmd_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_do_atcmd_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, command, message, eventname); + retVal___ = preHookFunc(&sd, &command, &message, &eventname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49692,11 +49862,11 @@ const char* HP_npc_parse_function(const char *w1, const char *w2, const char *w3 int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_function_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_function_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_function_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49718,11 +49888,11 @@ const char* HP_npc_parse_function(const char *w1, const char *w2, const char *w3 void HP_npc_parse_mob2(struct spawn_data *mobspawn) { int hIndex = 0; if( HPMHooks.count.HP_npc_parse_mob2_pre ) { - void (*preHookFunc) (struct spawn_data *mobspawn); + void (*preHookFunc) (struct spawn_data **mobspawn); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_mob2_pre[hIndex].func; - preHookFunc(mobspawn); + preHookFunc(&mobspawn); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49745,11 +49915,11 @@ const char* HP_npc_parse_mob(const char *w1, const char *w2, const char *w3, con int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_mob_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_mob_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49772,11 +49942,11 @@ const char* HP_npc_parse_mapflag(const char *w1, const char *w2, const char *w3, int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_npc_parse_mapflag_pre ) { - const char* (*preHookFunc) (const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mapflag_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_mapflag_pre[hIndex].func; - retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, retval); + retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49798,11 +49968,11 @@ const char* HP_npc_parse_mapflag(const char *w1, const char *w2, const char *w3, void HP_npc_parse_unknown_mapflag(const char *name, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) { int hIndex = 0; if( HPMHooks.count.HP_npc_parse_unknown_mapflag_pre ) { - void (*preHookFunc) (const char *name, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval); + void (*preHookFunc) (const char **name, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_mapflag_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parse_unknown_mapflag_pre[hIndex].func; - preHookFunc(name, w3, w4, start, buffer, filepath, retval); + preHookFunc(&name, &w3, &w4, &start, &buffer, &filepath, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49825,11 +49995,11 @@ int HP_npc_parsesrcfile(const char *filepath, bool runOnInit) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_parsesrcfile_pre ) { - int (*preHookFunc) (const char *filepath, bool *runOnInit); + int (*preHookFunc) (const char **filepath, bool *runOnInit); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_parsesrcfile_pre[hIndex].func; - retVal___ = preHookFunc(filepath, &runOnInit); + retVal___ = preHookFunc(&filepath, &runOnInit); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49840,10 +50010,10 @@ int HP_npc_parsesrcfile(const char *filepath, bool runOnInit) { retVal___ = HPMHooks.source.npc.parsesrcfile(filepath, runOnInit); } if( HPMHooks.count.HP_npc_parsesrcfile_post ) { - int (*postHookFunc) (int retVal___, 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; - retVal___ = postHookFunc(retVal___, filepath, &runOnInit); + retVal___ = postHookFunc(retVal___, filepath, runOnInit); } } return retVal___; @@ -49852,11 +50022,11 @@ int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_script_event_pre ) { - int (*preHookFunc) (struct map_session_data *sd, enum npce_event *type); + int (*preHookFunc) (struct map_session_data **sd, enum npce_event *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_script_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_script_event_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -49867,10 +50037,10 @@ int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) { retVal___ = HPMHooks.source.npc.script_event(sd, type); } if( HPMHooks.count.HP_npc_script_event_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum npce_event *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum npce_event type); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_script_event_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_script_event_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -49905,12 +50075,12 @@ int HP_npc_path_db_clear_sub(union DBKey key, struct DBData *data, va_list args) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_path_db_clear_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list args); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_path_db_clear_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_npc_path_db_clear_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, args___copy); + retVal___ = preHookFunc(&key, &data, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -49924,11 +50094,11 @@ int HP_npc_path_db_clear_sub(union DBKey key, struct DBData *data, va_list args) va_end(args___copy); } if( HPMHooks.count.HP_npc_path_db_clear_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list args); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_path_db_clear_sub_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_npc_path_db_clear_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, args___copy); + retVal___ = postHookFunc(retVal___, key, data, args___copy); va_end(args___copy); } } @@ -49938,12 +50108,12 @@ int HP_npc_ev_label_db_clear_sub(union DBKey key, struct DBData *data, va_list a int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list args); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_npc_ev_label_db_clear_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, args___copy); + retVal___ = preHookFunc(&key, &data, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -49957,11 +50127,11 @@ int HP_npc_ev_label_db_clear_sub(union DBKey key, struct DBData *data, va_list a va_end(args___copy); } if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list args); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ev_label_db_clear_sub_post; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); postHookFunc = HPMHooks.list.HP_npc_ev_label_db_clear_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, args___copy); + retVal___ = postHookFunc(retVal___, key, data, args___copy); va_end(args___copy); } } @@ -49998,11 +50168,11 @@ bool HP_npc_unloadfile(const char *filepath) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_unloadfile_pre ) { - bool (*preHookFunc) (const char *filepath); + bool (*preHookFunc) (const char **filepath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unloadfile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_unloadfile_pre[hIndex].func; - retVal___ = preHookFunc(filepath); + retVal___ = preHookFunc(&filepath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50050,11 +50220,11 @@ void HP_npc_do_clear_npc(void) { void HP_npc_debug_warps_sub(struct npc_data *nd) { int hIndex = 0; if( HPMHooks.count.HP_npc_debug_warps_sub_pre ) { - void (*preHookFunc) (struct npc_data *nd); + void (*preHookFunc) (struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_debug_warps_sub_pre[hIndex].func; - preHookFunc(nd); + preHookFunc(&nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50102,11 +50272,11 @@ void HP_npc_debug_warps(void) { void HP_npc_trader_count_funds(struct npc_data *nd, struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_npc_trader_count_funds_pre ) { - void (*preHookFunc) (struct npc_data *nd, struct map_session_data *sd); + void (*preHookFunc) (struct npc_data **nd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_count_funds_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_trader_count_funds_pre[hIndex].func; - preHookFunc(nd, sd); + preHookFunc(&nd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50129,11 +50299,11 @@ bool HP_npc_trader_pay(struct npc_data *nd, struct map_session_data *sd, int pri int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_trader_pay_pre ) { - bool (*preHookFunc) (struct npc_data *nd, struct map_session_data *sd, int *price, int *points); + bool (*preHookFunc) (struct npc_data **nd, struct map_session_data **sd, int *price, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_pay_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_trader_pay_pre[hIndex].func; - retVal___ = preHookFunc(nd, sd, &price, &points); + retVal___ = preHookFunc(&nd, &sd, &price, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50144,10 +50314,10 @@ bool HP_npc_trader_pay(struct npc_data *nd, struct map_session_data *sd, int pri retVal___ = HPMHooks.source.npc.trader_pay(nd, sd, price, points); } if( HPMHooks.count.HP_npc_trader_pay_post ) { - bool (*postHookFunc) (bool retVal___, struct npc_data *nd, struct map_session_data *sd, int *price, int *points); + bool (*postHookFunc) (bool retVal___, struct npc_data *nd, struct map_session_data *sd, int price, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_pay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_trader_pay_post[hIndex].func; - retVal___ = postHookFunc(retVal___, nd, sd, &price, &points); + retVal___ = postHookFunc(retVal___, nd, sd, price, points); } } return retVal___; @@ -50170,10 +50340,10 @@ void HP_npc_trader_update(int master) { HPMHooks.source.npc.trader_update(master); } if( HPMHooks.count.HP_npc_trader_update_post ) { - void (*postHookFunc) (int *master); + void (*postHookFunc) (int master); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_trader_update_post[hIndex].func; - postHookFunc(&master); + postHookFunc(master); } } return; @@ -50182,11 +50352,11 @@ int HP_npc_market_buylist(struct map_session_data *sd, struct itemlist *item_lis int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_npc_market_buylist_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_buylist_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_market_buylist_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list); + retVal___ = preHookFunc(&sd, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50209,11 +50379,11 @@ bool HP_npc_trader_open(struct map_session_data *sd, struct npc_data *nd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_npc_trader_open_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd); + bool (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_trader_open_pre[hIndex].func; - retVal___ = preHookFunc(sd, nd); + retVal___ = preHookFunc(&sd, &nd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50261,11 +50431,11 @@ void HP_npc_market_fromsql(void) { void HP_npc_market_tosql(struct npc_data *nd, unsigned short index) { int hIndex = 0; if( HPMHooks.count.HP_npc_market_tosql_pre ) { - void (*preHookFunc) (struct npc_data *nd, unsigned short *index); + void (*preHookFunc) (struct npc_data **nd, unsigned short *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_tosql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_market_tosql_pre[hIndex].func; - preHookFunc(nd, &index); + preHookFunc(&nd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50276,10 +50446,10 @@ void HP_npc_market_tosql(struct npc_data *nd, unsigned short index) { HPMHooks.source.npc.market_tosql(nd, index); } if( HPMHooks.count.HP_npc_market_tosql_post ) { - void (*postHookFunc) (struct npc_data *nd, unsigned short *index); + void (*postHookFunc) (struct npc_data *nd, unsigned short index); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_tosql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_market_tosql_post[hIndex].func; - postHookFunc(nd, &index); + postHookFunc(nd, index); } } return; @@ -50287,11 +50457,11 @@ void HP_npc_market_tosql(struct npc_data *nd, unsigned short index) { void HP_npc_market_delfromsql(struct npc_data *nd, unsigned short index) { int hIndex = 0; if( HPMHooks.count.HP_npc_market_delfromsql_pre ) { - void (*preHookFunc) (struct npc_data *nd, unsigned short *index); + void (*preHookFunc) (struct npc_data **nd, unsigned short *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_market_delfromsql_pre[hIndex].func; - preHookFunc(nd, &index); + preHookFunc(&nd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50302,10 +50472,10 @@ void HP_npc_market_delfromsql(struct npc_data *nd, unsigned short index) { HPMHooks.source.npc.market_delfromsql(nd, index); } if( HPMHooks.count.HP_npc_market_delfromsql_post ) { - void (*postHookFunc) (struct npc_data *nd, unsigned short *index); + void (*postHookFunc) (struct npc_data *nd, unsigned short index); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_market_delfromsql_post[hIndex].func; - postHookFunc(nd, &index); + postHookFunc(nd, index); } } return; @@ -50313,11 +50483,11 @@ void HP_npc_market_delfromsql(struct npc_data *nd, unsigned short index) { void HP_npc_market_delfromsql_sub(const char *npcname, unsigned short index) { int hIndex = 0; if( HPMHooks.count.HP_npc_market_delfromsql_sub_pre ) { - void (*preHookFunc) (const char *npcname, unsigned short *index); + void (*preHookFunc) (const char **npcname, unsigned short *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_npc_market_delfromsql_sub_pre[hIndex].func; - preHookFunc(npcname, &index); + preHookFunc(&npcname, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50328,10 +50498,10 @@ void HP_npc_market_delfromsql_sub(const char *npcname, unsigned short index) { HPMHooks.source.npc.market_delfromsql_sub(npcname, index); } if( HPMHooks.count.HP_npc_market_delfromsql_sub_post ) { - void (*postHookFunc) (const char *npcname, unsigned short *index); + void (*postHookFunc) (const char *npcname, unsigned short index); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_market_delfromsql_sub_post[hIndex].func; - postHookFunc(npcname, &index); + postHookFunc(npcname, index); } } return; @@ -50355,10 +50525,10 @@ bool HP_npc_db_checkid(const int id) { retVal___ = HPMHooks.source.npc.db_checkid(id); } if( HPMHooks.count.HP_npc_db_checkid_post ) { - bool (*postHookFunc) (bool retVal___, const int *id); + bool (*postHookFunc) (bool retVal___, const int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_db_checkid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_db_checkid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -50382,10 +50552,10 @@ int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.npc.secure_timeout_timer(tid, tick, id, data); } if( HPMHooks.count.HP_npc_secure_timeout_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_secure_timeout_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_npc_secure_timeout_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -50394,11 +50564,11 @@ int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) { void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) { int hIndex = 0; if( HPMHooks.count.HP_nullpo_assert_report_pre ) { - void (*preHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*preHookFunc) (const char **file, int *line, const char **func, const char **targetname, const char **title); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func; - preHookFunc(file, &line, func, targetname, title); + preHookFunc(&file, &line, &func, &targetname, &title); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50409,10 +50579,10 @@ void HP_nullpo_assert_report(const char *file, int line, const char *func, const HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title); } if( HPMHooks.count.HP_nullpo_assert_report_post ) { - void (*postHookFunc) (const char *file, int *line, const char *func, const char *targetname, const char *title); + void (*postHookFunc) (const char *file, int line, const char *func, const char *targetname, const char *title); for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func; - postHookFunc(file, &line, func, targetname, title); + postHookFunc(file, line, func, targetname, title); } } return; @@ -50436,10 +50606,10 @@ void HP_party_init(bool minimal) { HPMHooks.source.party.init(minimal); } if( HPMHooks.count.HP_party_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -50489,10 +50659,10 @@ struct party_data* HP_party_search(int party_id) { retVal___ = HPMHooks.source.party.search(party_id); } if( HPMHooks.count.HP_party_search_post ) { - struct party_data* (*postHookFunc) (struct party_data* retVal___, int *party_id); + struct party_data* (*postHookFunc) (struct party_data* retVal___, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id); + retVal___ = postHookFunc(retVal___, party_id); } } return retVal___; @@ -50501,11 +50671,11 @@ struct party_data* HP_party_searchname(const char *str) { int hIndex = 0; struct party_data* retVal___ = NULL; if( HPMHooks.count.HP_party_searchname_pre ) { - struct party_data* (*preHookFunc) (const char *str); + struct party_data* (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_searchname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_searchname_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50528,11 +50698,11 @@ int HP_party_getmemberid(struct party_data *p, struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_getmemberid_pre ) { - int (*preHookFunc) (struct party_data *p, struct map_session_data *sd); + int (*preHookFunc) (struct party_data **p, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getmemberid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_getmemberid_pre[hIndex].func; - retVal___ = preHookFunc(p, sd); + retVal___ = preHookFunc(&p, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50555,11 +50725,11 @@ struct map_session_data* HP_party_getavailablesd(struct party_data *p) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_party_getavailablesd_pre ) { - struct map_session_data* (*preHookFunc) (struct party_data *p); + struct map_session_data* (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getavailablesd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_getavailablesd_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50582,11 +50752,11 @@ int HP_party_create(struct map_session_data *sd, const char *name, int item, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name, int *item, int *item2); + int (*preHookFunc) (struct map_session_data **sd, const char **name, int *item, int *item2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, name, &item, &item2); + retVal___ = preHookFunc(&sd, &name, &item, &item2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50597,10 +50767,10 @@ int HP_party_create(struct map_session_data *sd, const char *name, int item, int retVal___ = HPMHooks.source.party.create(sd, name, item, item2); } if( HPMHooks.count.HP_party_create_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int *item, int *item2); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int item, int item2); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, name, &item, &item2); + retVal___ = postHookFunc(retVal___, sd, name, item, item2); } } return retVal___; @@ -50608,11 +50778,11 @@ int HP_party_create(struct map_session_data *sd, const char *name, int item, int void HP_party_created(int account_id, int char_id, int fail, int party_id, const char *name) { int hIndex = 0; if( HPMHooks.count.HP_party_created_pre ) { - void (*preHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, const char *name); + void (*preHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_created_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_created_pre[hIndex].func; - preHookFunc(&account_id, &char_id, &fail, &party_id, name); + preHookFunc(&account_id, &char_id, &fail, &party_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50623,10 +50793,10 @@ void HP_party_created(int account_id, int char_id, int fail, int party_id, const HPMHooks.source.party.created(account_id, char_id, fail, party_id, name); } if( HPMHooks.count.HP_party_created_post ) { - void (*postHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, const char *name); + void (*postHookFunc) (int account_id, int char_id, int fail, int party_id, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_created_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_created_post[hIndex].func; - postHookFunc(&account_id, &char_id, &fail, &party_id, name); + postHookFunc(account_id, char_id, fail, party_id, name); } } return; @@ -50650,10 +50820,10 @@ int HP_party_request_info(int party_id, int char_id) { retVal___ = HPMHooks.source.party.request_info(party_id, char_id); } if( HPMHooks.count.HP_party_request_info_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_request_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_request_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, char_id); } } return retVal___; @@ -50662,11 +50832,11 @@ int HP_party_invite(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_invite_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_invite_pre[hIndex].func; - retVal___ = preHookFunc(sd, tsd); + retVal___ = preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50688,11 +50858,11 @@ int HP_party_invite(struct map_session_data *sd, struct map_session_data *tsd) { void HP_party_member_joined(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_party_member_joined_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_joined_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_member_joined_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50730,10 +50900,10 @@ int HP_party_member_added(int party_id, int account_id, int char_id, int flag) { retVal___ = HPMHooks.source.party.member_added(party_id, account_id, char_id, flag); } if( HPMHooks.count.HP_party_member_added_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id, int *flag); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_added_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_member_added_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id, &flag); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id, flag); } } return retVal___; @@ -50742,11 +50912,11 @@ int HP_party_leave(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_leave_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_leave_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_leave_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50769,11 +50939,11 @@ int HP_party_removemember(struct map_session_data *sd, int account_id, const cha int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_removemember_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *name); + int (*preHookFunc) (struct map_session_data **sd, int *account_id, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_removemember_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_removemember_pre[hIndex].func; - retVal___ = preHookFunc(sd, &account_id, name); + retVal___ = preHookFunc(&sd, &account_id, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50784,10 +50954,10 @@ int HP_party_removemember(struct map_session_data *sd, int account_id, const cha retVal___ = HPMHooks.source.party.removemember(sd, account_id, name); } if( HPMHooks.count.HP_party_removemember_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, const char *name); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_removemember_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_removemember_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &account_id, name); + retVal___ = postHookFunc(retVal___, sd, account_id, name); } } return retVal___; @@ -50811,10 +50981,10 @@ int HP_party_member_withdraw(int party_id, int account_id, int char_id) { retVal___ = HPMHooks.source.party.member_withdraw(party_id, account_id, char_id); } if( HPMHooks.count.HP_party_member_withdraw_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_member_withdraw_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -50822,11 +50992,11 @@ int HP_party_member_withdraw(int party_id, int account_id, int char_id) { void HP_party_reply_invite(struct map_session_data *sd, int party_id, int flag) { int hIndex = 0; if( HPMHooks.count.HP_party_reply_invite_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *party_id, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *party_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_reply_invite_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_reply_invite_pre[hIndex].func; - preHookFunc(sd, &party_id, &flag); + preHookFunc(&sd, &party_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50837,10 +51007,10 @@ void HP_party_reply_invite(struct map_session_data *sd, int party_id, int flag) HPMHooks.source.party.reply_invite(sd, party_id, flag); } if( HPMHooks.count.HP_party_reply_invite_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *party_id, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int party_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_reply_invite_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_reply_invite_post[hIndex].func; - postHookFunc(sd, &party_id, &flag); + postHookFunc(sd, party_id, flag); } } return; @@ -50864,10 +51034,10 @@ int HP_party_recv_noinfo(int party_id, int char_id) { retVal___ = HPMHooks.source.party.recv_noinfo(party_id, char_id); } if( HPMHooks.count.HP_party_recv_noinfo_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *char_id); + int (*postHookFunc) (int retVal___, int party_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_noinfo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recv_noinfo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, char_id); } } return retVal___; @@ -50876,11 +51046,11 @@ int HP_party_recv_info(const struct party *sp, int char_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_recv_info_pre ) { - int (*preHookFunc) (const struct party *sp, int *char_id); + int (*preHookFunc) (const struct party **sp, int *char_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_info_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_recv_info_pre[hIndex].func; - retVal___ = preHookFunc(sp, &char_id); + retVal___ = preHookFunc(&sp, &char_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50891,10 +51061,10 @@ int HP_party_recv_info(const struct party *sp, int char_id) { retVal___ = HPMHooks.source.party.recv_info(sp, char_id); } if( HPMHooks.count.HP_party_recv_info_post ) { - int (*postHookFunc) (int retVal___, const struct party *sp, int *char_id); + int (*postHookFunc) (int retVal___, const struct party *sp, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_info_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recv_info_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sp, &char_id); + retVal___ = postHookFunc(retVal___, sp, char_id); } } return retVal___; @@ -50918,10 +51088,10 @@ int HP_party_recv_movemap(int party_id, int account_id, int char_id, unsigned sh retVal___ = HPMHooks.source.party.recv_movemap(party_id, account_id, char_id, mapid, online, lv); } if( HPMHooks.count.HP_party_recv_movemap_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id, unsigned short *mapid, int *online, int *lv); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id, unsigned short mapid, int online, int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_movemap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recv_movemap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id, &mapid, &online, &lv); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id, mapid, online, lv); } } return retVal___; @@ -50945,10 +51115,10 @@ int HP_party_broken(int party_id) { retVal___ = HPMHooks.source.party.broken(party_id); } if( HPMHooks.count.HP_party_broken_post ) { - int (*postHookFunc) (int retVal___, int *party_id); + int (*postHookFunc) (int retVal___, int party_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_broken_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_broken_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id); + retVal___ = postHookFunc(retVal___, party_id); } } return retVal___; @@ -50972,10 +51142,10 @@ int HP_party_optionchanged(int party_id, int account_id, int exp, int item, int retVal___ = HPMHooks.source.party.optionchanged(party_id, account_id, exp, item, flag); } if( HPMHooks.count.HP_party_optionchanged_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *exp, int *item, int *flag); + int (*postHookFunc) (int retVal___, int party_id, int account_id, int exp, int item, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_optionchanged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_optionchanged_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &exp, &item, &flag); + retVal___ = postHookFunc(retVal___, party_id, account_id, exp, item, flag); } } return retVal___; @@ -50984,11 +51154,11 @@ int HP_party_changeoption(struct map_session_data *sd, int exp, int item) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_changeoption_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *exp, int *item); + int (*preHookFunc) (struct map_session_data **sd, int *exp, int *item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeoption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_changeoption_pre[hIndex].func; - retVal___ = preHookFunc(sd, &exp, &item); + retVal___ = preHookFunc(&sd, &exp, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -50999,10 +51169,10 @@ int HP_party_changeoption(struct map_session_data *sd, int exp, int item) { retVal___ = HPMHooks.source.party.changeoption(sd, exp, item); } if( HPMHooks.count.HP_party_changeoption_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *exp, int *item); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int exp, int item); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeoption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_changeoption_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &exp, &item); + retVal___ = postHookFunc(retVal___, sd, exp, item); } } return retVal___; @@ -51011,11 +51181,11 @@ bool HP_party_changeleader(struct map_session_data *sd, struct map_session_data int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_party_changeleader_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct map_session_data *t_sd); + bool (*preHookFunc) (struct map_session_data **sd, struct map_session_data **t_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeleader_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_changeleader_pre[hIndex].func; - retVal___ = preHookFunc(sd, t_sd); + retVal___ = preHookFunc(&sd, &t_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51037,11 +51207,11 @@ bool HP_party_changeleader(struct map_session_data *sd, struct map_session_data void HP_party_send_movemap(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_party_send_movemap_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_movemap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_movemap_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51063,11 +51233,11 @@ void HP_party_send_movemap(struct map_session_data *sd) { void HP_party_send_levelup(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_party_send_levelup_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_levelup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_levelup_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51090,11 +51260,11 @@ int HP_party_send_logout(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_send_logout_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_logout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_logout_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51113,15 +51283,15 @@ int HP_party_send_logout(struct map_session_data *sd) { } return retVal___; } -int HP_party_send_message(struct map_session_data *sd, const char *mes, int len) { +int HP_party_send_message(struct map_session_data *sd, const char *mes) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_send_message_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len); + int (*preHookFunc) (struct map_session_data **sd, const char **mes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_message_pre[hIndex].func; - retVal___ = preHookFunc(sd, mes, &len); + retVal___ = preHookFunc(&sd, &mes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51129,13 +51299,13 @@ int HP_party_send_message(struct map_session_data *sd, const char *mes, int len) } } { - retVal___ = HPMHooks.source.party.send_message(sd, mes, len); + retVal___ = HPMHooks.source.party.send_message(sd, mes); } if( HPMHooks.count.HP_party_send_message_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes, int *len); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_send_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, mes, &len); + retVal___ = postHookFunc(retVal___, sd, mes); } } return retVal___; @@ -51144,11 +51314,11 @@ int HP_party_recv_message(int party_id, int account_id, const char *mes, int len int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_recv_message_pre ) { - int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len); + int (*preHookFunc) (int *party_id, int *account_id, const char **mes, int *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_recv_message_pre[hIndex].func; - retVal___ = preHookFunc(&party_id, &account_id, mes, &len); + retVal___ = preHookFunc(&party_id, &account_id, &mes, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51159,10 +51329,10 @@ int HP_party_recv_message(int party_id, int account_id, const char *mes, int len retVal___ = HPMHooks.source.party.recv_message(party_id, account_id, mes, len); } if( HPMHooks.count.HP_party_recv_message_post ) { - int (*postHookFunc) (int retVal___, int *party_id, int *account_id, const char *mes, int *len); + int (*postHookFunc) (int retVal___, int party_id, int account_id, const char *mes, int len); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_message_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recv_message_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, mes, &len); + retVal___ = postHookFunc(retVal___, party_id, account_id, mes, len); } } return retVal___; @@ -51171,11 +51341,11 @@ int HP_party_skill_check(struct map_session_data *sd, int party_id, uint16 skill int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_skill_check_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *party_id, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, int *party_id, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_skill_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_skill_check_pre[hIndex].func; - retVal___ = preHookFunc(sd, &party_id, &skill_id, &skill_lv); + retVal___ = preHookFunc(&sd, &party_id, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51186,10 +51356,10 @@ int HP_party_skill_check(struct map_session_data *sd, int party_id, uint16 skill retVal___ = HPMHooks.source.party.skill_check(sd, party_id, skill_id, skill_lv); } if( HPMHooks.count.HP_party_skill_check_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *party_id, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_skill_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_skill_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &party_id, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, party_id, skill_id, skill_lv); } } return retVal___; @@ -51198,11 +51368,11 @@ int HP_party_send_xy_clear(struct party_data *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_send_xy_clear_pre ) { - int (*preHookFunc) (struct party_data *p); + int (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_xy_clear_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51225,11 +51395,11 @@ int HP_party_exp_share(struct party_data *p, struct block_list *src, unsigned in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_exp_share_pre ) { - int (*preHookFunc) (struct party_data *p, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, int *zeny); + int (*preHookFunc) (struct party_data **p, struct block_list **src, unsigned int *base_exp, unsigned int *job_exp, int *zeny); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_exp_share_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_exp_share_pre[hIndex].func; - retVal___ = preHookFunc(p, src, &base_exp, &job_exp, &zeny); + retVal___ = preHookFunc(&p, &src, &base_exp, &job_exp, &zeny); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51240,10 +51410,10 @@ int HP_party_exp_share(struct party_data *p, struct block_list *src, unsigned in retVal___ = HPMHooks.source.party.exp_share(p, src, base_exp, job_exp, zeny); } if( HPMHooks.count.HP_party_exp_share_post ) { - int (*postHookFunc) (int retVal___, struct party_data *p, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, int *zeny); + int (*postHookFunc) (int retVal___, struct party_data *p, struct block_list *src, unsigned int base_exp, unsigned int job_exp, int zeny); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_exp_share_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_exp_share_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, src, &base_exp, &job_exp, &zeny); + retVal___ = postHookFunc(retVal___, p, src, base_exp, job_exp, zeny); } } return retVal___; @@ -51252,11 +51422,11 @@ int HP_party_share_loot(struct party_data *p, struct map_session_data *sd, struc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_share_loot_pre ) { - int (*preHookFunc) (struct party_data *p, struct map_session_data *sd, struct item *item_data, int *first_charid); + int (*preHookFunc) (struct party_data **p, struct map_session_data **sd, struct item **item_data, int *first_charid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_share_loot_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_share_loot_pre[hIndex].func; - retVal___ = preHookFunc(p, sd, item_data, &first_charid); + retVal___ = preHookFunc(&p, &sd, &item_data, &first_charid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51267,10 +51437,10 @@ int HP_party_share_loot(struct party_data *p, struct map_session_data *sd, struc retVal___ = HPMHooks.source.party.share_loot(p, sd, item_data, first_charid); } if( HPMHooks.count.HP_party_share_loot_post ) { - int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd, struct item *item_data, int *first_charid); + int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd, struct item *item_data, int first_charid); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_share_loot_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_share_loot_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, sd, item_data, &first_charid); + retVal___ = postHookFunc(retVal___, p, sd, item_data, first_charid); } } return retVal___; @@ -51279,11 +51449,11 @@ int HP_party_send_dot_remove(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_send_dot_remove_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_dot_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_send_dot_remove_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51306,12 +51476,12 @@ int HP_party_sub_count(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_sub_count_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_party_sub_count_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -51339,12 +51509,12 @@ int HP_party_sub_count_chorus(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_sub_count_chorus_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_chorus_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_party_sub_count_chorus_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -51371,11 +51541,11 @@ int HP_party_sub_count_chorus(struct block_list *bl, va_list ap) { void HP_party_booking_register(struct map_session_data *sd, short level, short mapid, short *job) { int hIndex = 0; if( HPMHooks.count.HP_party_booking_register_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job); + void (*preHookFunc) (struct map_session_data **sd, short *level, short *mapid, short **job); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_register_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_booking_register_pre[hIndex].func; - preHookFunc(sd, &level, &mapid, job); + preHookFunc(&sd, &level, &mapid, &job); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51386,10 +51556,10 @@ void HP_party_booking_register(struct map_session_data *sd, short level, short m HPMHooks.source.party.booking_register(sd, level, mapid, job); } if( HPMHooks.count.HP_party_booking_register_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job); + void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, short *job); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_register_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_booking_register_post[hIndex].func; - postHookFunc(sd, &level, &mapid, job); + postHookFunc(sd, level, mapid, job); } } return; @@ -51397,11 +51567,11 @@ void HP_party_booking_register(struct map_session_data *sd, short level, short m void HP_party_booking_update(struct map_session_data *sd, short *job) { int hIndex = 0; if( HPMHooks.count.HP_party_booking_update_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *job); + void (*preHookFunc) (struct map_session_data **sd, short **job); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_booking_update_pre[hIndex].func; - preHookFunc(sd, job); + preHookFunc(&sd, &job); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51423,11 +51593,11 @@ void HP_party_booking_update(struct map_session_data *sd, short *job) { void HP_party_booking_search(struct map_session_data *sd, short level, short mapid, short job, unsigned long lastindex, short resultcount) { int hIndex = 0; if( HPMHooks.count.HP_party_booking_search_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job, unsigned long *lastindex, short *resultcount); + void (*preHookFunc) (struct map_session_data **sd, short *level, short *mapid, short *job, unsigned long *lastindex, short *resultcount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_booking_search_pre[hIndex].func; - preHookFunc(sd, &level, &mapid, &job, &lastindex, &resultcount); + preHookFunc(&sd, &level, &mapid, &job, &lastindex, &resultcount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51438,10 +51608,10 @@ void HP_party_booking_search(struct map_session_data *sd, short level, short map HPMHooks.source.party.booking_search(sd, level, mapid, job, lastindex, resultcount); } if( HPMHooks.count.HP_party_booking_search_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job, unsigned long *lastindex, short *resultcount); + void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, short job, unsigned long lastindex, short resultcount); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_booking_search_post[hIndex].func; - postHookFunc(sd, &level, &mapid, &job, &lastindex, &resultcount); + postHookFunc(sd, level, mapid, job, lastindex, resultcount); } } return; @@ -51449,11 +51619,11 @@ void HP_party_booking_search(struct map_session_data *sd, short level, short map void HP_party_recruit_register(struct map_session_data *sd, short level, const char *notice) { int hIndex = 0; if( HPMHooks.count.HP_party_recruit_register_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *level, const char *notice); + void (*preHookFunc) (struct map_session_data **sd, short *level, const char **notice); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_register_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_recruit_register_pre[hIndex].func; - preHookFunc(sd, &level, notice); + preHookFunc(&sd, &level, ¬ice); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51464,10 +51634,10 @@ void HP_party_recruit_register(struct map_session_data *sd, short level, const c HPMHooks.source.party.recruit_register(sd, level, notice); } if( HPMHooks.count.HP_party_recruit_register_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *level, const char *notice); + void (*postHookFunc) (struct map_session_data *sd, short level, const char *notice); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_register_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recruit_register_post[hIndex].func; - postHookFunc(sd, &level, notice); + postHookFunc(sd, level, notice); } } return; @@ -51475,11 +51645,11 @@ void HP_party_recruit_register(struct map_session_data *sd, short level, const c void HP_party_recruit_update(struct map_session_data *sd, const char *notice) { int hIndex = 0; if( HPMHooks.count.HP_party_recruit_update_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *notice); + void (*preHookFunc) (struct map_session_data **sd, const char **notice); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_recruit_update_pre[hIndex].func; - preHookFunc(sd, notice); + preHookFunc(&sd, ¬ice); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51501,11 +51671,11 @@ void HP_party_recruit_update(struct map_session_data *sd, const char *notice) { void HP_party_recruit_search(struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount) { int hIndex = 0; if( HPMHooks.count.HP_party_recruit_search_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount); + void (*preHookFunc) (struct map_session_data **sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_recruit_search_pre[hIndex].func; - preHookFunc(sd, &level, &mapid, &lastindex, &resultcount); + preHookFunc(&sd, &level, &mapid, &lastindex, &resultcount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51516,10 +51686,10 @@ void HP_party_recruit_search(struct map_session_data *sd, short level, short map HPMHooks.source.party.recruit_search(sd, level, mapid, lastindex, resultcount); } if( HPMHooks.count.HP_party_recruit_search_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount); + void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_recruit_search_post[hIndex].func; - postHookFunc(sd, &level, &mapid, &lastindex, &resultcount); + postHookFunc(sd, level, mapid, lastindex, resultcount); } } return; @@ -51528,11 +51698,11 @@ bool HP_party_booking_delete(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_party_booking_delete_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_booking_delete_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51555,12 +51725,12 @@ int HP_party_vforeachsamemap(int ( *func ) (struct block_list *, va_list), struc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_vforeachsamemap_pre ) { - int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int *range, va_list ap); + int (*preHookFunc) (int ( **func ) (struct block_list *, va_list), struct map_session_data **sd, int *range, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_vforeachsamemap_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_party_vforeachsamemap_pre[hIndex].func; - retVal___ = preHookFunc(func, sd, &range, ap___copy); + retVal___ = preHookFunc(&func, &sd, &range, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -51574,11 +51744,11 @@ int HP_party_vforeachsamemap(int ( *func ) (struct block_list *, va_list), struc va_end(ap___copy); } if( HPMHooks.count.HP_party_vforeachsamemap_post ) { - int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int *range, va_list ap); + int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int range, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_vforeachsamemap_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_party_vforeachsamemap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, func, sd, &range, ap___copy); + retVal___ = postHookFunc(retVal___, func, sd, range, ap___copy); va_end(ap___copy); } } @@ -51603,10 +51773,10 @@ int HP_party_send_xy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.party.send_xy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_party_send_xy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_send_xy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -51614,11 +51784,11 @@ int HP_party_send_xy_timer(int tid, int64 tick, int id, intptr_t data) { void HP_party_fill_member(struct party_member *member, struct map_session_data *sd, unsigned int leader) { int hIndex = 0; if( HPMHooks.count.HP_party_fill_member_pre ) { - void (*preHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int *leader); + void (*preHookFunc) (struct party_member **member, struct map_session_data **sd, unsigned int *leader); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_fill_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_fill_member_pre[hIndex].func; - preHookFunc(member, sd, &leader); + preHookFunc(&member, &sd, &leader); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51629,10 +51799,10 @@ void HP_party_fill_member(struct party_member *member, struct map_session_data * HPMHooks.source.party.fill_member(member, sd, leader); } if( HPMHooks.count.HP_party_fill_member_post ) { - void (*postHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int *leader); + void (*postHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int leader); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_fill_member_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_fill_member_post[hIndex].func; - postHookFunc(member, sd, &leader); + postHookFunc(member, sd, leader); } } return; @@ -51656,10 +51826,10 @@ struct map_session_data* HP_party_sd_check(int party_id, int account_id, int cha retVal___ = HPMHooks.source.party.sd_check(party_id, account_id, char_id); } if( HPMHooks.count.HP_party_sd_check_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *party_id, int *account_id, int *char_id); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int party_id, int account_id, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sd_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_party_sd_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id); + retVal___ = postHookFunc(retVal___, party_id, account_id, char_id); } } return retVal___; @@ -51667,11 +51837,11 @@ struct map_session_data* HP_party_sd_check(int party_id, int account_id, int cha void HP_party_check_state(struct party_data *p) { int hIndex = 0; if( HPMHooks.count.HP_party_check_state_pre ) { - void (*preHookFunc) (struct party_data *p); + void (*preHookFunc) (struct party_data **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_check_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_party_check_state_pre[hIndex].func; - preHookFunc(p); + preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51721,12 +51891,12 @@ int HP_party_db_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_party_db_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_party_db_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_party_db_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -51740,11 +51910,11 @@ int HP_party_db_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_party_db_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_party_db_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_party_db_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -51755,11 +51925,11 @@ int HP_path_blownpos(struct block_list *bl, int16 m, int16 x0, int16 y0, int16 d int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_path_blownpos_pre ) { - int (*preHookFunc) (struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count); + int (*preHookFunc) (struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_path_blownpos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_path_blownpos_pre[hIndex].func; - retVal___ = preHookFunc(bl, &m, &x0, &y0, &dx, &dy, &count); + retVal___ = preHookFunc(&bl, &m, &x0, &y0, &dx, &dy, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51770,10 +51940,10 @@ int HP_path_blownpos(struct block_list *bl, int16 m, int16 x0, int16 y0, int16 d retVal___ = HPMHooks.source.path.blownpos(bl, m, x0, y0, dx, dy, count); } if( HPMHooks.count.HP_path_blownpos_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count); + int (*postHookFunc) (int retVal___, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_blownpos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_blownpos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &m, &x0, &y0, &dx, &dy, &count); + retVal___ = postHookFunc(retVal___, bl, m, x0, y0, dx, dy, count); } } return retVal___; @@ -51782,11 +51952,11 @@ bool HP_path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, i int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_path_search_pre ) { - bool (*preHookFunc) (struct walkpath_data *wpd, struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell); + bool (*preHookFunc) (struct walkpath_data **wpd, struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_path_search_pre[hIndex].func; - retVal___ = preHookFunc(wpd, bl, &m, &x0, &y0, &x1, &y1, &flag, &cell); + retVal___ = preHookFunc(&wpd, &bl, &m, &x0, &y0, &x1, &y1, &flag, &cell); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51797,10 +51967,10 @@ bool HP_path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, i retVal___ = HPMHooks.source.path.search(wpd, bl, m, x0, y0, x1, y1, flag, cell); } if( HPMHooks.count.HP_path_search_post ) { - bool (*postHookFunc) (bool retVal___, struct walkpath_data *wpd, struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell); + bool (*postHookFunc) (bool retVal___, struct walkpath_data *wpd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, wpd, bl, &m, &x0, &y0, &x1, &y1, &flag, &cell); + retVal___ = postHookFunc(retVal___, wpd, bl, m, x0, y0, x1, y1, flag, cell); } } return retVal___; @@ -51809,11 +51979,11 @@ bool HP_path_search_long(struct shootpath_data *spd, struct block_list *bl, int1 int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_path_search_long_pre ) { - bool (*preHookFunc) (struct shootpath_data *spd, struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell); + bool (*preHookFunc) (struct shootpath_data **spd, struct block_list **bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_long_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_path_search_long_pre[hIndex].func; - retVal___ = preHookFunc(spd, bl, &m, &x0, &y0, &x1, &y1, &cell); + retVal___ = preHookFunc(&spd, &bl, &m, &x0, &y0, &x1, &y1, &cell); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -51824,10 +51994,10 @@ bool HP_path_search_long(struct shootpath_data *spd, struct block_list *bl, int1 retVal___ = HPMHooks.source.path.search_long(spd, bl, m, x0, y0, x1, y1, cell); } if( HPMHooks.count.HP_path_search_long_post ) { - bool (*postHookFunc) (bool retVal___, struct shootpath_data *spd, struct block_list *bl, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell); + bool (*postHookFunc) (bool retVal___, struct shootpath_data *spd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, cell_chk cell); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_long_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_search_long_post[hIndex].func; - retVal___ = postHookFunc(retVal___, spd, bl, &m, &x0, &y0, &x1, &y1, &cell); + retVal___ = postHookFunc(retVal___, spd, bl, m, x0, y0, x1, y1, cell); } } return retVal___; @@ -51851,10 +52021,10 @@ bool HP_path_check_distance(int dx, int dy, int distance) { retVal___ = HPMHooks.source.path.check_distance(dx, dy, distance); } if( HPMHooks.count.HP_path_check_distance_post ) { - bool (*postHookFunc) (bool retVal___, int *dx, int *dy, int *distance); + bool (*postHookFunc) (bool retVal___, int dx, int dy, int distance); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_check_distance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &dx, &dy, &distance); + retVal___ = postHookFunc(retVal___, dx, dy, distance); } } return retVal___; @@ -51878,10 +52048,10 @@ unsigned int HP_path_distance(int dx, int dy) { retVal___ = HPMHooks.source.path.distance(dx, dy); } if( HPMHooks.count.HP_path_distance_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, int *dx, int *dy); + unsigned int (*postHookFunc) (unsigned int retVal___, int dx, int dy); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_distance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &dx, &dy); + retVal___ = postHookFunc(retVal___, dx, dy); } } return retVal___; @@ -51905,10 +52075,10 @@ bool HP_path_check_distance_client(int dx, int dy, int distance) { retVal___ = HPMHooks.source.path.check_distance_client(dx, dy, distance); } if( HPMHooks.count.HP_path_check_distance_client_post ) { - bool (*postHookFunc) (bool retVal___, int *dx, int *dy, int *distance); + bool (*postHookFunc) (bool retVal___, int dx, int dy, int distance); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_client_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_check_distance_client_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &dx, &dy, &distance); + retVal___ = postHookFunc(retVal___, dx, dy, distance); } } return retVal___; @@ -51932,10 +52102,10 @@ int HP_path_distance_client(int dx, int dy) { retVal___ = HPMHooks.source.path.distance_client(dx, dy); } if( HPMHooks.count.HP_path_distance_client_post ) { - int (*postHookFunc) (int retVal___, int *dx, int *dy); + int (*postHookFunc) (int retVal___, int dx, int dy); for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_client_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_path_distance_client_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &dx, &dy); + retVal___ = postHookFunc(retVal___, dx, dy); } } return retVal___; @@ -52065,10 +52235,10 @@ bool HP_pcg_exists(int group_id) { retVal___ = HPMHooks.source.pcg.exists(group_id); } if( HPMHooks.count.HP_pcg_exists_post ) { - bool (*postHookFunc) (bool retVal___, int *group_id); + 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); + retVal___ = postHookFunc(retVal___, group_id); } } return retVal___; @@ -52092,10 +52262,10 @@ GroupSettings* HP_pcg_id2group(int group_id) { retVal___ = HPMHooks.source.pcg.id2group(group_id); } if( HPMHooks.count.HP_pcg_id2group_post ) { - GroupSettings* (*postHookFunc) (GroupSettings* retVal___, int *group_id); + 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); + retVal___ = postHookFunc(retVal___, group_id); } } return retVal___; @@ -52104,11 +52274,11 @@ 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); + bool (*preHookFunc) (GroupSettings **group, unsigned int *permission); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&group, &permission); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52119,10 +52289,10 @@ bool HP_pcg_has_permission(GroupSettings *group, unsigned int permission) { 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); + 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); + retVal___ = postHookFunc(retVal___, group, permission); } } return retVal___; @@ -52131,11 +52301,11 @@ 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); + bool (*preHookFunc) (GroupSettings **group); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52158,11 +52328,11 @@ 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); + const char* (*preHookFunc) (GroupSettings **group); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52185,11 +52355,11 @@ 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); + int (*preHookFunc) (GroupSettings **group); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52212,11 +52382,11 @@ 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); + int (*preHookFunc) (GroupSettings **group); *HPMforce_return = false; 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); + retVal___ = preHookFunc(&group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52254,10 +52424,10 @@ void HP_pc_init(bool minimal) { HPMHooks.source.pc.init(minimal); } if( HPMHooks.count.HP_pc_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -52334,10 +52504,10 @@ int HP_pc_class2idx(int class_) { retVal___ = HPMHooks.source.pc.class2idx(class_); } if( HPMHooks.count.HP_pc_class2idx_post ) { - int (*postHookFunc) (int retVal___, int *class_); + int (*postHookFunc) (int retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_class2idx_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_class2idx_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -52346,11 +52516,11 @@ bool HP_pc_can_talk(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_talk_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_talk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_talk_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52373,11 +52543,11 @@ bool HP_pc_can_attack(struct map_session_data *sd, int target_id) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_attack_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *target_id); + bool (*preHookFunc) (struct map_session_data **sd, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_attack_pre[hIndex].func; - retVal___ = preHookFunc(sd, &target_id); + retVal___ = preHookFunc(&sd, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52388,10 +52558,10 @@ bool HP_pc_can_attack(struct map_session_data *sd, int target_id) { retVal___ = HPMHooks.source.pc.can_attack(sd, target_id); } if( HPMHooks.count.HP_pc_can_attack_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *target_id); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_can_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &target_id); + retVal___ = postHookFunc(retVal___, sd, target_id); } } return retVal___; @@ -52400,11 +52570,11 @@ bool HP_pc_can_use_command(struct map_session_data *sd, const char *command) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_use_command_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const char *command); + bool (*preHookFunc) (struct map_session_data **sd, const char **command); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_use_command_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_use_command_pre[hIndex].func; - retVal___ = preHookFunc(sd, command); + retVal___ = preHookFunc(&sd, &command); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52427,11 +52597,11 @@ int HP_pc_set_group(struct map_session_data *sd, int group_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_set_group_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *group_id); + int (*preHookFunc) (struct map_session_data **sd, int *group_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_group_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_set_group_pre[hIndex].func; - retVal___ = preHookFunc(sd, &group_id); + retVal___ = preHookFunc(&sd, &group_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52442,10 +52612,10 @@ int HP_pc_set_group(struct map_session_data *sd, int group_id) { retVal___ = HPMHooks.source.pc.set_group(sd, group_id); } if( HPMHooks.count.HP_pc_set_group_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *group_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int group_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_group_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_set_group_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &group_id); + retVal___ = postHookFunc(retVal___, sd, group_id); } } return retVal___; @@ -52454,11 +52624,11 @@ bool HP_pc_should_log_commands(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_should_log_commands_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_should_log_commands_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_should_log_commands_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52481,11 +52651,11 @@ int HP_pc_setrestartvalue(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setrestartvalue_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setrestartvalue_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52496,10 +52666,10 @@ int HP_pc_setrestartvalue(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.setrestartvalue(sd, type); } if( HPMHooks.count.HP_pc_setrestartvalue_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setrestartvalue_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -52508,11 +52678,11 @@ int HP_pc_makesavestatus(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_makesavestatus_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_makesavestatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_makesavestatus_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52534,11 +52704,11 @@ int HP_pc_makesavestatus(struct map_session_data *sd) { void HP_pc_respawn(struct map_session_data *sd, clr_type clrtype) { int hIndex = 0; if( HPMHooks.count.HP_pc_respawn_pre ) { - void (*preHookFunc) (struct map_session_data *sd, clr_type *clrtype); + void (*preHookFunc) (struct map_session_data **sd, clr_type *clrtype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_respawn_pre[hIndex].func; - preHookFunc(sd, &clrtype); + preHookFunc(&sd, &clrtype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52549,10 +52719,10 @@ void HP_pc_respawn(struct map_session_data *sd, clr_type clrtype) { HPMHooks.source.pc.respawn(sd, clrtype); } if( HPMHooks.count.HP_pc_respawn_post ) { - void (*postHookFunc) (struct map_session_data *sd, clr_type *clrtype); + void (*postHookFunc) (struct map_session_data *sd, clr_type clrtype); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_respawn_post[hIndex].func; - postHookFunc(sd, &clrtype); + postHookFunc(sd, clrtype); } } return; @@ -52561,11 +52731,11 @@ int HP_pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setnewpc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd); + int (*preHookFunc) (struct map_session_data **sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setnewpc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setnewpc_pre[hIndex].func; - retVal___ = preHookFunc(sd, &account_id, &char_id, &login_id1, &client_tick, &sex, &fd); + retVal___ = preHookFunc(&sd, &account_id, &char_id, &login_id1, &client_tick, &sex, &fd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52576,10 +52746,10 @@ int HP_pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int retVal___ = HPMHooks.source.pc.setnewpc(sd, account_id, char_id, login_id1, client_tick, sex, fd); } if( HPMHooks.count.HP_pc_setnewpc_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, int char_id, int login_id1, unsigned int client_tick, int sex, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setnewpc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setnewpc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &account_id, &char_id, &login_id1, &client_tick, &sex, &fd); + retVal___ = postHookFunc(retVal___, sd, account_id, char_id, login_id1, client_tick, sex, fd); } } return retVal___; @@ -52588,11 +52758,11 @@ bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_ int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_authok_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *login_id2, time_t *expiration_time, int *group_id, const struct mmo_charstatus *st, bool *changing_mapservers); + bool (*preHookFunc) (struct map_session_data **sd, int *login_id2, time_t *expiration_time, int *group_id, const struct mmo_charstatus **st, bool *changing_mapservers); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_authok_pre[hIndex].func; - retVal___ = preHookFunc(sd, &login_id2, &expiration_time, &group_id, st, &changing_mapservers); + retVal___ = preHookFunc(&sd, &login_id2, &expiration_time, &group_id, &st, &changing_mapservers); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52603,10 +52773,10 @@ bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_ retVal___ = HPMHooks.source.pc.authok(sd, login_id2, expiration_time, group_id, st, changing_mapservers); } if( HPMHooks.count.HP_pc_authok_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *login_id2, time_t *expiration_time, int *group_id, const struct mmo_charstatus *st, bool *changing_mapservers); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, const struct mmo_charstatus *st, bool changing_mapservers); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_authok_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &login_id2, &expiration_time, &group_id, st, &changing_mapservers); + retVal___ = postHookFunc(retVal___, sd, login_id2, expiration_time, group_id, st, changing_mapservers); } } return retVal___; @@ -52614,11 +52784,11 @@ bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_ void HP_pc_authfail(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_authfail_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authfail_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_authfail_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52641,11 +52811,11 @@ int HP_pc_reg_received(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_reg_received_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_reg_received_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_reg_received_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52668,11 +52838,11 @@ int HP_pc_isequip(struct map_session_data *sd, int n) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_isequip_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n); + int (*preHookFunc) (struct map_session_data **sd, int *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_isequip_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n); + retVal___ = preHookFunc(&sd, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52683,10 +52853,10 @@ int HP_pc_isequip(struct map_session_data *sd, int n) { retVal___ = HPMHooks.source.pc.isequip(sd, n); } if( HPMHooks.count.HP_pc_isequip_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_isequip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n); + retVal___ = postHookFunc(retVal___, sd, n); } } return retVal___; @@ -52695,11 +52865,11 @@ int HP_pc_equippoint(struct map_session_data *sd, int n) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_equippoint_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n); + int (*preHookFunc) (struct map_session_data **sd, int *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_equippoint_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n); + retVal___ = preHookFunc(&sd, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52710,10 +52880,10 @@ int HP_pc_equippoint(struct map_session_data *sd, int n) { retVal___ = HPMHooks.source.pc.equippoint(sd, n); } if( HPMHooks.count.HP_pc_equippoint_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_equippoint_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n); + retVal___ = postHookFunc(retVal___, sd, n); } } return retVal___; @@ -52722,11 +52892,11 @@ int HP_pc_setinventorydata(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setinventorydata_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinventorydata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setinventorydata_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52749,11 +52919,11 @@ int HP_pc_checkskill(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkskill_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkskill_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52764,10 +52934,10 @@ int HP_pc_checkskill(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.pc.checkskill(sd, skill_id); } if( HPMHooks.count.HP_pc_checkskill_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_checkskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -52776,11 +52946,11 @@ int HP_pc_checkskill2(struct map_session_data *sd, uint16 index) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkskill2_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *index); + int (*preHookFunc) (struct map_session_data **sd, uint16 *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkskill2_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index); + retVal___ = preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52791,10 +52961,10 @@ int HP_pc_checkskill2(struct map_session_data *sd, uint16 index) { retVal___ = HPMHooks.source.pc.checkskill2(sd, index); } if( HPMHooks.count.HP_pc_checkskill2_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *index); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 index); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_checkskill2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index); + retVal___ = postHookFunc(retVal___, sd, index); } } return retVal___; @@ -52803,11 +52973,11 @@ int HP_pc_checkallowskill(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkallowskill_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkallowskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkallowskill_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52830,11 +53000,11 @@ int HP_pc_checkequip(struct map_session_data *sd, int pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkequip_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *pos); + int (*preHookFunc) (struct map_session_data **sd, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkequip_pre[hIndex].func; - retVal___ = preHookFunc(sd, &pos); + retVal___ = preHookFunc(&sd, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52845,10 +53015,10 @@ int HP_pc_checkequip(struct map_session_data *sd, int pos) { retVal___ = HPMHooks.source.pc.checkequip(sd, pos); } if( HPMHooks.count.HP_pc_checkequip_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_checkequip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &pos); + retVal___ = postHookFunc(retVal___, sd, pos); } } return retVal___; @@ -52857,11 +53027,11 @@ int HP_pc_calc_skilltree(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_calc_skilltree_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52884,11 +53054,11 @@ int HP_pc_calc_skilltree_normalize_job(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_calc_skilltree_normalize_job_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_normalize_job_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_normalize_job_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52911,11 +53081,11 @@ int HP_pc_clean_skilltree(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_clean_skilltree_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clean_skilltree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_clean_skilltree_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52938,11 +53108,11 @@ int HP_pc_setpos(struct map_session_data *sd, unsigned short map_index, int x, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setpos_pre ) { - int (*preHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, clr_type *clrtype); + int (*preHookFunc) (struct map_session_data **sd, unsigned short *map_index, int *x, int *y, clr_type *clrtype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setpos_pre[hIndex].func; - retVal___ = preHookFunc(sd, &map_index, &x, &y, &clrtype); + retVal___ = preHookFunc(&sd, &map_index, &x, &y, &clrtype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52953,10 +53123,10 @@ int HP_pc_setpos(struct map_session_data *sd, unsigned short map_index, int x, i retVal___ = HPMHooks.source.pc.setpos(sd, map_index, x, y, clrtype); } if( HPMHooks.count.HP_pc_setpos_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, unsigned short *map_index, int *x, int *y, clr_type *clrtype); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, unsigned short map_index, int x, int y, clr_type clrtype); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setpos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &map_index, &x, &y, &clrtype); + retVal___ = postHookFunc(retVal___, sd, map_index, x, y, clrtype); } } return retVal___; @@ -52965,11 +53135,11 @@ int HP_pc_setsavepoint(struct map_session_data *sd, short map_index, int x, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setsavepoint_pre ) { - int (*preHookFunc) (struct map_session_data *sd, short *map_index, int *x, int *y); + int (*preHookFunc) (struct map_session_data **sd, short *map_index, int *x, int *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setsavepoint_pre[hIndex].func; - retVal___ = preHookFunc(sd, &map_index, &x, &y); + retVal___ = preHookFunc(&sd, &map_index, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -52980,10 +53150,10 @@ int HP_pc_setsavepoint(struct map_session_data *sd, short map_index, int x, int retVal___ = HPMHooks.source.pc.setsavepoint(sd, map_index, x, y); } if( HPMHooks.count.HP_pc_setsavepoint_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *map_index, int *x, int *y); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, short map_index, int x, int y); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setsavepoint_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &map_index, &x, &y); + retVal___ = postHookFunc(retVal___, sd, map_index, x, y); } } return retVal___; @@ -52992,11 +53162,11 @@ int HP_pc_randomwarp(struct map_session_data *sd, clr_type type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_randomwarp_pre ) { - int (*preHookFunc) (struct map_session_data *sd, clr_type *type); + int (*preHookFunc) (struct map_session_data **sd, clr_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_randomwarp_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53007,10 +53177,10 @@ int HP_pc_randomwarp(struct map_session_data *sd, clr_type type) { retVal___ = HPMHooks.source.pc.randomwarp(sd, type); } if( HPMHooks.count.HP_pc_randomwarp_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, clr_type *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, clr_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_randomwarp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -53019,11 +53189,11 @@ int HP_pc_memo(struct map_session_data *sd, int pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_memo_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *pos); + int (*preHookFunc) (struct map_session_data **sd, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_memo_pre[hIndex].func; - retVal___ = preHookFunc(sd, &pos); + retVal___ = preHookFunc(&sd, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53034,10 +53204,10 @@ int HP_pc_memo(struct map_session_data *sd, int pos) { retVal___ = HPMHooks.source.pc.memo(sd, pos); } if( HPMHooks.count.HP_pc_memo_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_memo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &pos); + retVal___ = postHookFunc(retVal___, sd, pos); } } return retVal___; @@ -53046,11 +53216,11 @@ int HP_pc_checkadditem(struct map_session_data *sd, int nameid, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkadditem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *nameid, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkadditem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkadditem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid, &amount); + retVal___ = preHookFunc(&sd, &nameid, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53061,10 +53231,10 @@ int HP_pc_checkadditem(struct map_session_data *sd, int nameid, int amount) { retVal___ = HPMHooks.source.pc.checkadditem(sd, nameid, amount); } if( HPMHooks.count.HP_pc_checkadditem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkadditem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_checkadditem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid, &amount); + retVal___ = postHookFunc(retVal___, sd, nameid, amount); } } return retVal___; @@ -53073,11 +53243,11 @@ int HP_pc_inventoryblank(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_inventoryblank_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventoryblank_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_inventoryblank_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53100,11 +53270,11 @@ int HP_pc_search_inventory(struct map_session_data *sd, int item_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_search_inventory_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *item_id); + int (*preHookFunc) (struct map_session_data **sd, int *item_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_search_inventory_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_search_inventory_pre[hIndex].func; - retVal___ = preHookFunc(sd, &item_id); + retVal___ = preHookFunc(&sd, &item_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53115,10 +53285,10 @@ int HP_pc_search_inventory(struct map_session_data *sd, int item_id) { retVal___ = HPMHooks.source.pc.search_inventory(sd, item_id); } if( HPMHooks.count.HP_pc_search_inventory_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *item_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int item_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_search_inventory_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_search_inventory_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &item_id); + retVal___ = postHookFunc(retVal___, sd, item_id); } } return retVal___; @@ -53127,11 +53297,11 @@ int HP_pc_payzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_payzeny_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, int *zeny, enum e_log_pick_type *type, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_payzeny_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_payzeny_pre[hIndex].func; - retVal___ = preHookFunc(sd, &zeny, &type, tsd); + retVal___ = preHookFunc(&sd, &zeny, &type, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53142,10 +53312,10 @@ int HP_pc_payzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty retVal___ = HPMHooks.source.pc.payzeny(sd, zeny, type, tsd); } if( HPMHooks.count.HP_pc_payzeny_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_payzeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_payzeny_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &zeny, &type, tsd); + retVal___ = postHookFunc(retVal___, sd, zeny, type, tsd); } } return retVal___; @@ -53154,11 +53324,11 @@ int HP_pc_additem(struct map_session_data *sd, struct item *item_data, int amoun int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_additem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type); + int (*preHookFunc) (struct map_session_data **sd, struct item **item_data, int *amount, e_log_pick_type *log_type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_additem_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_data, &amount, &log_type); + retVal___ = preHookFunc(&sd, &item_data, &amount, &log_type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53169,10 +53339,10 @@ int HP_pc_additem(struct map_session_data *sd, struct item *item_data, int amoun retVal___ = HPMHooks.source.pc.additem(sd, item_data, amount, log_type); } if( HPMHooks.count.HP_pc_additem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_additem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, item_data, &amount, &log_type); + retVal___ = postHookFunc(retVal___, sd, item_data, amount, log_type); } } return retVal___; @@ -53181,11 +53351,11 @@ int HP_pc_getzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_getzeny_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, int *zeny, enum e_log_pick_type *type, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getzeny_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_getzeny_pre[hIndex].func; - retVal___ = preHookFunc(sd, &zeny, &type, tsd); + retVal___ = preHookFunc(&sd, &zeny, &type, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53196,10 +53366,10 @@ int HP_pc_getzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty retVal___ = HPMHooks.source.pc.getzeny(sd, zeny, type, tsd); } if( HPMHooks.count.HP_pc_getzeny_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getzeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_getzeny_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &zeny, &type, tsd); + retVal___ = postHookFunc(retVal___, sd, zeny, type, tsd); } } return retVal___; @@ -53208,11 +53378,11 @@ int HP_pc_delitem(struct map_session_data *sd, int n, int amount, int type, shor int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_delitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_delitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &amount, &type, &reason, &log_type); + retVal___ = preHookFunc(&sd, &n, &amount, &type, &reason, &log_type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53223,10 +53393,10 @@ int HP_pc_delitem(struct map_session_data *sd, int n, int amount, int type, shor retVal___ = HPMHooks.source.pc.delitem(sd, n, amount, type, reason, log_type); } if( HPMHooks.count.HP_pc_delitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount, int type, short reason, e_log_pick_type log_type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_delitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &amount, &type, &reason, &log_type); + retVal___ = postHookFunc(retVal___, sd, n, amount, type, reason, log_type); } } return retVal___; @@ -53235,11 +53405,11 @@ int HP_pc_paycash(struct map_session_data *sd, int price, int points) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_paycash_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *price, int *points); + int (*preHookFunc) (struct map_session_data **sd, int *price, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_paycash_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_paycash_pre[hIndex].func; - retVal___ = preHookFunc(sd, &price, &points); + retVal___ = preHookFunc(&sd, &price, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53250,10 +53420,10 @@ int HP_pc_paycash(struct map_session_data *sd, int price, int points) { retVal___ = HPMHooks.source.pc.paycash(sd, price, points); } if( HPMHooks.count.HP_pc_paycash_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *price, int *points); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int price, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_paycash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_paycash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &price, &points); + retVal___ = postHookFunc(retVal___, sd, price, points); } } return retVal___; @@ -53262,11 +53432,11 @@ int HP_pc_getcash(struct map_session_data *sd, int cash, int points) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_getcash_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *cash, int *points); + int (*preHookFunc) (struct map_session_data **sd, int *cash, int *points); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getcash_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_getcash_pre[hIndex].func; - retVal___ = preHookFunc(sd, &cash, &points); + retVal___ = preHookFunc(&sd, &cash, &points); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53277,10 +53447,10 @@ int HP_pc_getcash(struct map_session_data *sd, int cash, int points) { retVal___ = HPMHooks.source.pc.getcash(sd, cash, points); } if( HPMHooks.count.HP_pc_getcash_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *cash, int *points); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int cash, int points); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getcash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_getcash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &cash, &points); + retVal___ = postHookFunc(retVal___, sd, cash, points); } } return retVal___; @@ -53289,11 +53459,11 @@ int HP_pc_cart_additem(struct map_session_data *sd, struct item *item_data, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_cart_additem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type); + int (*preHookFunc) (struct map_session_data **sd, struct item **item_data, int *amount, e_log_pick_type *log_type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_cart_additem_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_data, &amount, &log_type); + retVal___ = preHookFunc(&sd, &item_data, &amount, &log_type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53304,10 +53474,10 @@ int HP_pc_cart_additem(struct map_session_data *sd, struct item *item_data, int retVal___ = HPMHooks.source.pc.cart_additem(sd, item_data, amount, log_type); } if( HPMHooks.count.HP_pc_cart_additem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_cart_additem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, item_data, &amount, &log_type); + retVal___ = postHookFunc(retVal___, sd, item_data, amount, log_type); } } return retVal___; @@ -53316,11 +53486,11 @@ int HP_pc_cart_delitem(struct map_session_data *sd, int n, int amount, int type, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_cart_delitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *type, e_log_pick_type *log_type); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *type, e_log_pick_type *log_type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_cart_delitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &amount, &type, &log_type); + retVal___ = preHookFunc(&sd, &n, &amount, &type, &log_type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53331,10 +53501,10 @@ int HP_pc_cart_delitem(struct map_session_data *sd, int n, int amount, int type, retVal___ = HPMHooks.source.pc.cart_delitem(sd, n, amount, type, log_type); } if( HPMHooks.count.HP_pc_cart_delitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount, int *type, e_log_pick_type *log_type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount, int type, e_log_pick_type log_type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_cart_delitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &amount, &type, &log_type); + retVal___ = postHookFunc(retVal___, sd, n, amount, type, log_type); } } return retVal___; @@ -53343,11 +53513,11 @@ int HP_pc_putitemtocart(struct map_session_data *sd, int idx, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_putitemtocart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *idx, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_putitemtocart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_putitemtocart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx, &amount); + retVal___ = preHookFunc(&sd, &idx, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53358,10 +53528,10 @@ int HP_pc_putitemtocart(struct map_session_data *sd, int idx, int amount) { retVal___ = HPMHooks.source.pc.putitemtocart(sd, idx, amount); } if( HPMHooks.count.HP_pc_putitemtocart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_putitemtocart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_putitemtocart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx, &amount); + retVal___ = postHookFunc(retVal___, sd, idx, amount); } } return retVal___; @@ -53370,11 +53540,11 @@ int HP_pc_getitemfromcart(struct map_session_data *sd, int idx, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_getitemfromcart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *idx, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getitemfromcart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_getitemfromcart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx, &amount); + retVal___ = preHookFunc(&sd, &idx, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53385,10 +53555,10 @@ int HP_pc_getitemfromcart(struct map_session_data *sd, int idx, int amount) { retVal___ = HPMHooks.source.pc.getitemfromcart(sd, idx, amount); } if( HPMHooks.count.HP_pc_getitemfromcart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getitemfromcart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_getitemfromcart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx, &amount); + retVal___ = postHookFunc(retVal___, sd, idx, amount); } } return retVal___; @@ -53397,11 +53567,11 @@ int HP_pc_cartitem_amount(struct map_session_data *sd, int idx, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_cartitem_amount_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *idx, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cartitem_amount_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_cartitem_amount_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx, &amount); + retVal___ = preHookFunc(&sd, &idx, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53412,10 +53582,10 @@ int HP_pc_cartitem_amount(struct map_session_data *sd, int idx, int amount) { retVal___ = HPMHooks.source.pc.cartitem_amount(sd, idx, amount); } if( HPMHooks.count.HP_pc_cartitem_amount_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cartitem_amount_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_cartitem_amount_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx, &amount); + retVal___ = postHookFunc(retVal___, sd, idx, amount); } } return retVal___; @@ -53424,11 +53594,11 @@ int HP_pc_takeitem(struct map_session_data *sd, struct flooritem_data *fitem) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_takeitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem); + int (*preHookFunc) (struct map_session_data **sd, struct flooritem_data **fitem); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_takeitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_takeitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, fitem); + retVal___ = preHookFunc(&sd, &fitem); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53451,11 +53621,11 @@ int HP_pc_dropitem(struct map_session_data *sd, int n, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_dropitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dropitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_dropitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &amount); + retVal___ = preHookFunc(&sd, &n, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53466,10 +53636,10 @@ int HP_pc_dropitem(struct map_session_data *sd, int n, int amount) { retVal___ = HPMHooks.source.pc.dropitem(sd, n, amount); } if( HPMHooks.count.HP_pc_dropitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dropitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_dropitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &amount); + retVal___ = postHookFunc(retVal___, sd, n, amount); } } return retVal___; @@ -53478,11 +53648,11 @@ bool HP_pc_isequipped(struct map_session_data *sd, int nameid) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_isequipped_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *nameid); + bool (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_isequipped_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53493,10 +53663,10 @@ bool HP_pc_isequipped(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.pc.isequipped(sd, nameid); } if( HPMHooks.count.HP_pc_isequipped_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *nameid); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_isequipped_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -53505,11 +53675,11 @@ bool HP_pc_can_Adopt(struct map_session_data *p1_sd, struct map_session_data *p2 int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_Adopt_pre ) { - bool (*preHookFunc) (struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd); + bool (*preHookFunc) (struct map_session_data **p1_sd, struct map_session_data **p2_sd, struct map_session_data **b_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_Adopt_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_Adopt_pre[hIndex].func; - retVal___ = preHookFunc(p1_sd, p2_sd, b_sd); + retVal___ = preHookFunc(&p1_sd, &p2_sd, &b_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53532,11 +53702,11 @@ bool HP_pc_adoption(struct map_session_data *p1_sd, struct map_session_data *p2_ int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_adoption_pre ) { - bool (*preHookFunc) (struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd); + bool (*preHookFunc) (struct map_session_data **p1_sd, struct map_session_data **p2_sd, struct map_session_data **b_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_adoption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_adoption_pre[hIndex].func; - retVal___ = preHookFunc(p1_sd, p2_sd, b_sd); + retVal___ = preHookFunc(&p1_sd, &p2_sd, &b_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53559,11 +53729,11 @@ int HP_pc_updateweightstatus(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_updateweightstatus_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_updateweightstatus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_updateweightstatus_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53586,11 +53756,11 @@ int HP_pc_addautobonus(struct s_autobonus *bonus, char max, const char *bonus_sc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_addautobonus_pre ) { - int (*preHookFunc) (struct s_autobonus *bonus, char *max, const char *bonus_script, short *rate, unsigned int *dur, short *atk_type, const char *o_script, unsigned short *pos, bool *onskill); + int (*preHookFunc) (struct s_autobonus **bonus, char *max, const char **bonus_script, short *rate, unsigned int *dur, short *atk_type, const char **o_script, unsigned short *pos, bool *onskill); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addautobonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_addautobonus_pre[hIndex].func; - retVal___ = preHookFunc(bonus, &max, bonus_script, &rate, &dur, &atk_type, o_script, &pos, &onskill); + retVal___ = preHookFunc(&bonus, &max, &bonus_script, &rate, &dur, &atk_type, &o_script, &pos, &onskill); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53601,10 +53771,10 @@ int HP_pc_addautobonus(struct s_autobonus *bonus, char max, const char *bonus_sc retVal___ = HPMHooks.source.pc.addautobonus(bonus, max, bonus_script, rate, dur, atk_type, o_script, pos, onskill); } if( HPMHooks.count.HP_pc_addautobonus_post ) { - int (*postHookFunc) (int retVal___, struct s_autobonus *bonus, char *max, const char *bonus_script, short *rate, unsigned int *dur, short *atk_type, const char *o_script, unsigned short *pos, bool *onskill); + int (*postHookFunc) (int retVal___, struct s_autobonus *bonus, char max, const char *bonus_script, short rate, unsigned int dur, short atk_type, const char *o_script, unsigned short pos, bool onskill); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addautobonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_addautobonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bonus, &max, bonus_script, &rate, &dur, &atk_type, o_script, &pos, &onskill); + retVal___ = postHookFunc(retVal___, bonus, max, bonus_script, rate, dur, atk_type, o_script, pos, onskill); } } return retVal___; @@ -53613,11 +53783,11 @@ int HP_pc_exeautobonus(struct map_session_data *sd, struct s_autobonus *bonus) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_exeautobonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus); + int (*preHookFunc) (struct map_session_data **sd, struct s_autobonus **bonus); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_exeautobonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_exeautobonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, bonus); + retVal___ = preHookFunc(&sd, &bonus); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53655,10 +53825,10 @@ int HP_pc_endautobonus(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.endautobonus(tid, tick, id, data); } if( HPMHooks.count.HP_pc_endautobonus_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_endautobonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_endautobonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -53667,11 +53837,11 @@ int HP_pc_delautobonus(struct map_session_data *sd, struct s_autobonus *bonus, c int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_delautobonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus, char *max, bool *restore); + int (*preHookFunc) (struct map_session_data **sd, struct s_autobonus **bonus, char *max, bool *restore); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delautobonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_delautobonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, bonus, &max, &restore); + retVal___ = preHookFunc(&sd, &bonus, &max, &restore); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53682,10 +53852,10 @@ int HP_pc_delautobonus(struct map_session_data *sd, struct s_autobonus *bonus, c retVal___ = HPMHooks.source.pc.delautobonus(sd, bonus, max, restore); } if( HPMHooks.count.HP_pc_delautobonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus, char *max, bool *restore); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus, char max, bool restore); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delautobonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_delautobonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, bonus, &max, &restore); + retVal___ = postHookFunc(retVal___, sd, bonus, max, restore); } } return retVal___; @@ -53694,11 +53864,11 @@ int HP_pc_bonus(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53709,10 +53879,10 @@ int HP_pc_bonus(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.bonus(sd, type, val); } if( HPMHooks.count.HP_pc_bonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -53721,11 +53891,11 @@ int HP_pc_bonus2(struct map_session_data *sd, int type, int type2, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus2_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *type2, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus2_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &type2, &val); + retVal___ = preHookFunc(&sd, &type, &type2, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53736,10 +53906,10 @@ int HP_pc_bonus2(struct map_session_data *sd, int type, int type2, int val) { retVal___ = HPMHooks.source.pc.bonus2(sd, type, type2, val); } if( HPMHooks.count.HP_pc_bonus2_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &type2, &val); + retVal___ = postHookFunc(retVal___, sd, type, type2, val); } } return retVal___; @@ -53748,11 +53918,11 @@ int HP_pc_bonus3(struct map_session_data *sd, int type, int type2, int type3, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus3_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *type2, int *type3, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus3_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus3_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &type2, &type3, &val); + retVal___ = preHookFunc(&sd, &type, &type2, &type3, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53763,10 +53933,10 @@ int HP_pc_bonus3(struct map_session_data *sd, int type, int type2, int type3, in retVal___ = HPMHooks.source.pc.bonus3(sd, type, type2, type3, val); } if( HPMHooks.count.HP_pc_bonus3_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus3_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus3_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &val); + retVal___ = postHookFunc(retVal___, sd, type, type2, type3, val); } } return retVal___; @@ -53775,11 +53945,11 @@ int HP_pc_bonus4(struct map_session_data *sd, int type, int type2, int type3, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus4_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *type2, int *type3, int *type4, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus4_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus4_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &type2, &type3, &type4, &val); + retVal___ = preHookFunc(&sd, &type, &type2, &type3, &type4, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53790,10 +53960,10 @@ int HP_pc_bonus4(struct map_session_data *sd, int type, int type2, int type3, in retVal___ = HPMHooks.source.pc.bonus4(sd, type, type2, type3, type4, val); } if( HPMHooks.count.HP_pc_bonus4_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus4_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus4_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &type4, &val); + retVal___ = postHookFunc(retVal___, sd, type, type2, type3, type4, val); } } return retVal___; @@ -53802,11 +53972,11 @@ int HP_pc_bonus5(struct map_session_data *sd, int type, int type2, int type3, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus5_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus5_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus5_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &type2, &type3, &type4, &type5, &val); + retVal___ = preHookFunc(&sd, &type, &type2, &type3, &type4, &type5, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53817,10 +53987,10 @@ int HP_pc_bonus5(struct map_session_data *sd, int type, int type2, int type3, in retVal___ = HPMHooks.source.pc.bonus5(sd, type, type2, type3, type4, type5, val); } if( HPMHooks.count.HP_pc_bonus5_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int type5, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus5_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus5_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &type4, &type5, &val); + retVal___ = postHookFunc(retVal___, sd, type, type2, type3, type4, type5, val); } } return retVal___; @@ -53829,11 +53999,11 @@ int HP_pc_skill(struct map_session_data *sd, int id, int level, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_skill_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *id, int *level, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *id, int *level, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_skill_pre[hIndex].func; - retVal___ = preHookFunc(sd, &id, &level, &flag); + retVal___ = preHookFunc(&sd, &id, &level, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53844,10 +54014,10 @@ int HP_pc_skill(struct map_session_data *sd, int id, int level, int flag) { retVal___ = HPMHooks.source.pc.skill(sd, id, level, flag); } if( HPMHooks.count.HP_pc_skill_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, int *level, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, int level, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_skill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &id, &level, &flag); + retVal___ = postHookFunc(retVal___, sd, id, level, flag); } } return retVal___; @@ -53856,11 +54026,11 @@ int HP_pc_insert_card(struct map_session_data *sd, int idx_card, int idx_equip) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_insert_card_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *idx_card, int *idx_equip); + int (*preHookFunc) (struct map_session_data **sd, int *idx_card, int *idx_equip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_insert_card_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_insert_card_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx_card, &idx_equip); + retVal___ = preHookFunc(&sd, &idx_card, &idx_equip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53871,10 +54041,10 @@ int HP_pc_insert_card(struct map_session_data *sd, int idx_card, int idx_equip) retVal___ = HPMHooks.source.pc.insert_card(sd, idx_card, idx_equip); } if( HPMHooks.count.HP_pc_insert_card_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx_card, int *idx_equip); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx_card, int idx_equip); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_insert_card_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_insert_card_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx_card, &idx_equip); + retVal___ = postHookFunc(retVal___, sd, idx_card, idx_equip); } } return retVal___; @@ -53883,11 +54053,11 @@ bool HP_pc_can_insert_card(struct map_session_data *sd, int idx_card) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_insert_card_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *idx_card); + bool (*preHookFunc) (struct map_session_data **sd, int *idx_card); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_insert_card_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx_card); + retVal___ = preHookFunc(&sd, &idx_card); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53898,10 +54068,10 @@ bool HP_pc_can_insert_card(struct map_session_data *sd, int idx_card) { retVal___ = HPMHooks.source.pc.can_insert_card(sd, idx_card); } if( HPMHooks.count.HP_pc_can_insert_card_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *idx_card); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int idx_card); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_can_insert_card_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx_card); + retVal___ = postHookFunc(retVal___, sd, idx_card); } } return retVal___; @@ -53910,11 +54080,11 @@ bool HP_pc_can_insert_card_into(struct map_session_data *sd, int idx_card, int i int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_can_insert_card_into_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *idx_card, int *idx_equip); + bool (*preHookFunc) (struct map_session_data **sd, int *idx_card, int *idx_equip); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_into_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_can_insert_card_into_pre[hIndex].func; - retVal___ = preHookFunc(sd, &idx_card, &idx_equip); + retVal___ = preHookFunc(&sd, &idx_card, &idx_equip); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53925,10 +54095,10 @@ bool HP_pc_can_insert_card_into(struct map_session_data *sd, int idx_card, int i retVal___ = HPMHooks.source.pc.can_insert_card_into(sd, idx_card, idx_equip); } if( HPMHooks.count.HP_pc_can_insert_card_into_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *idx_card, int *idx_equip); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int idx_card, int idx_equip); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_into_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_can_insert_card_into_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &idx_card, &idx_equip); + retVal___ = postHookFunc(retVal___, sd, idx_card, idx_equip); } } return retVal___; @@ -53937,11 +54107,11 @@ int HP_pc_steal_item(struct map_session_data *sd, struct block_list *bl, uint16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_steal_item_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_steal_item_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl, &skill_lv); + retVal___ = preHookFunc(&sd, &bl, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53952,10 +54122,10 @@ int HP_pc_steal_item(struct map_session_data *sd, struct block_list *bl, uint16 retVal___ = HPMHooks.source.pc.steal_item(sd, bl, skill_lv); } if( HPMHooks.count.HP_pc_steal_item_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_item_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_steal_item_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, bl, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, bl, skill_lv); } } return retVal___; @@ -53964,11 +54134,11 @@ int HP_pc_steal_coin(struct map_session_data *sd, struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_steal_coin_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_coin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_steal_coin_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl); + retVal___ = preHookFunc(&sd, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -53991,11 +54161,11 @@ int HP_pc_modifybuyvalue(struct map_session_data *sd, int orig_value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_modifybuyvalue_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *orig_value); + int (*preHookFunc) (struct map_session_data **sd, int *orig_value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifybuyvalue_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_modifybuyvalue_pre[hIndex].func; - retVal___ = preHookFunc(sd, &orig_value); + retVal___ = preHookFunc(&sd, &orig_value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54006,10 +54176,10 @@ int HP_pc_modifybuyvalue(struct map_session_data *sd, int orig_value) { retVal___ = HPMHooks.source.pc.modifybuyvalue(sd, orig_value); } if( HPMHooks.count.HP_pc_modifybuyvalue_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *orig_value); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int orig_value); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifybuyvalue_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_modifybuyvalue_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &orig_value); + retVal___ = postHookFunc(retVal___, sd, orig_value); } } return retVal___; @@ -54018,11 +54188,11 @@ int HP_pc_modifysellvalue(struct map_session_data *sd, int orig_value) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_modifysellvalue_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *orig_value); + int (*preHookFunc) (struct map_session_data **sd, int *orig_value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifysellvalue_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_modifysellvalue_pre[hIndex].func; - retVal___ = preHookFunc(sd, &orig_value); + retVal___ = preHookFunc(&sd, &orig_value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54033,10 +54203,10 @@ int HP_pc_modifysellvalue(struct map_session_data *sd, int orig_value) { retVal___ = HPMHooks.source.pc.modifysellvalue(sd, orig_value); } if( HPMHooks.count.HP_pc_modifysellvalue_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *orig_value); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int orig_value); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifysellvalue_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_modifysellvalue_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &orig_value); + retVal___ = postHookFunc(retVal___, sd, orig_value); } } return retVal___; @@ -54045,11 +54215,11 @@ int HP_pc_follow(struct map_session_data *sd, int target_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_follow_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *target_id); + int (*preHookFunc) (struct map_session_data **sd, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_follow_pre[hIndex].func; - retVal___ = preHookFunc(sd, &target_id); + retVal___ = preHookFunc(&sd, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54060,10 +54230,10 @@ int HP_pc_follow(struct map_session_data *sd, int target_id) { retVal___ = HPMHooks.source.pc.follow(sd, target_id); } if( HPMHooks.count.HP_pc_follow_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_follow_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &target_id); + retVal___ = postHookFunc(retVal___, sd, target_id); } } return retVal___; @@ -54072,11 +54242,11 @@ int HP_pc_stop_following(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_stop_following_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_stop_following_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_stop_following_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54099,11 +54269,11 @@ unsigned int HP_pc_maxbaselv(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_maxbaselv_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxbaselv_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_maxbaselv_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54126,11 +54296,11 @@ unsigned int HP_pc_maxjoblv(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_maxjoblv_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxjoblv_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_maxjoblv_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54153,11 +54323,11 @@ int HP_pc_checkbaselevelup(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkbaselevelup_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54180,11 +54350,11 @@ int HP_pc_checkjoblevelup(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkjoblevelup_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkjoblevelup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkjoblevelup_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54207,11 +54377,11 @@ bool HP_pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_gainexp_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest); + bool (*preHookFunc) (struct map_session_data **sd, struct block_list **src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gainexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_gainexp_pre[hIndex].func; - retVal___ = preHookFunc(sd, src, &base_exp, &job_exp, &is_quest); + retVal___ = preHookFunc(&sd, &src, &base_exp, &job_exp, &is_quest); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54222,10 +54392,10 @@ bool HP_pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned retVal___ = HPMHooks.source.pc.gainexp(sd, src, base_exp, job_exp, is_quest); } if( HPMHooks.count.HP_pc_gainexp_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct block_list *src, unsigned int base_exp, unsigned int job_exp, bool is_quest); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gainexp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_gainexp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, src, &base_exp, &job_exp, &is_quest); + retVal___ = postHookFunc(retVal___, sd, src, base_exp, job_exp, is_quest); } } return retVal___; @@ -54234,11 +54404,11 @@ unsigned int HP_pc_nextbaseexp(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_nextbaseexp_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextbaseexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_nextbaseexp_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54261,11 +54431,11 @@ unsigned int HP_pc_thisbaseexp(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_thisbaseexp_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisbaseexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_thisbaseexp_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54288,11 +54458,11 @@ unsigned int HP_pc_nextjobexp(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_nextjobexp_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextjobexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_nextjobexp_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54315,11 +54485,11 @@ unsigned int HP_pc_thisjobexp(struct map_session_data *sd) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_pc_thisjobexp_pre ) { - unsigned int (*preHookFunc) (struct map_session_data *sd); + unsigned int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisjobexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_thisjobexp_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54357,10 +54527,10 @@ int HP_pc_gets_status_point(int level) { retVal___ = HPMHooks.source.pc.gets_status_point(level); } if( HPMHooks.count.HP_pc_gets_status_point_post ) { - int (*postHookFunc) (int retVal___, int *level); + int (*postHookFunc) (int retVal___, int level); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gets_status_point_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_gets_status_point_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &level); + retVal___ = postHookFunc(retVal___, level); } } return retVal___; @@ -54369,11 +54539,11 @@ int HP_pc_need_status_point(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_need_status_point_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_need_status_point_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_need_status_point_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54384,10 +54554,10 @@ int HP_pc_need_status_point(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.need_status_point(sd, type, val); } if( HPMHooks.count.HP_pc_need_status_point_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_need_status_point_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_need_status_point_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -54396,11 +54566,11 @@ int HP_pc_maxparameterincrease(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_maxparameterincrease_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxparameterincrease_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_maxparameterincrease_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54411,10 +54581,10 @@ int HP_pc_maxparameterincrease(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.maxparameterincrease(sd, type); } if( HPMHooks.count.HP_pc_maxparameterincrease_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxparameterincrease_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_maxparameterincrease_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -54423,11 +54593,11 @@ bool HP_pc_statusup(struct map_session_data *sd, int type, int increase) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_statusup_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *type, int *increase); + bool (*preHookFunc) (struct map_session_data **sd, int *type, int *increase); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_statusup_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &increase); + retVal___ = preHookFunc(&sd, &type, &increase); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54438,10 +54608,10 @@ bool HP_pc_statusup(struct map_session_data *sd, int type, int increase) { retVal___ = HPMHooks.source.pc.statusup(sd, type, increase); } if( HPMHooks.count.HP_pc_statusup_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *type, int *increase); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int type, int increase); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_statusup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &increase); + retVal___ = postHookFunc(retVal___, sd, type, increase); } } return retVal___; @@ -54450,11 +54620,11 @@ int HP_pc_statusup2(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_statusup2_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_statusup2_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54465,10 +54635,10 @@ int HP_pc_statusup2(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.statusup2(sd, type, val); } if( HPMHooks.count.HP_pc_statusup2_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_statusup2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -54477,11 +54647,11 @@ int HP_pc_skillup(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_skillup_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_skillup_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54492,10 +54662,10 @@ int HP_pc_skillup(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.pc.skillup(sd, skill_id); } if( HPMHooks.count.HP_pc_skillup_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_skillup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -54504,11 +54674,11 @@ int HP_pc_allskillup(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_allskillup_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_allskillup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_allskillup_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54531,11 +54701,11 @@ int HP_pc_resetlvl(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_resetlvl_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_resetlvl_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54546,10 +54716,10 @@ int HP_pc_resetlvl(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.resetlvl(sd, type); } if( HPMHooks.count.HP_pc_resetlvl_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_resetlvl_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -54558,11 +54728,11 @@ int HP_pc_resetstate(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_resetstate_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetstate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_resetstate_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54585,11 +54755,11 @@ int HP_pc_resetskill(struct map_session_data *sd, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_resetskill_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_resetskill_pre[hIndex].func; - retVal___ = preHookFunc(sd, &flag); + retVal___ = preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54600,10 +54770,10 @@ int HP_pc_resetskill(struct map_session_data *sd, int flag) { retVal___ = HPMHooks.source.pc.resetskill(sd, flag); } if( HPMHooks.count.HP_pc_resetskill_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_resetskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &flag); + retVal___ = postHookFunc(retVal___, sd, flag); } } return retVal___; @@ -54612,11 +54782,11 @@ int HP_pc_resetfeel(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_resetfeel_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetfeel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_resetfeel_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54639,11 +54809,11 @@ int HP_pc_resethate(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_resethate_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resethate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_resethate_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54666,11 +54836,11 @@ int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_equipitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *req_pos); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *req_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_equipitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &req_pos); + retVal___ = preHookFunc(&sd, &n, &req_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54681,10 +54851,10 @@ int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) { retVal___ = HPMHooks.source.pc.equipitem(sd, n, req_pos); } if( HPMHooks.count.HP_pc_equipitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *req_pos); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int req_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_equipitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &req_pos); + retVal___ = postHookFunc(retVal___, sd, n, req_pos); } } return retVal___; @@ -54692,11 +54862,11 @@ int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) { void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int n, int pos) { int hIndex = 0; if( HPMHooks.count.HP_pc_equipitem_pos_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_data *id, int *n, int *pos); + void (*preHookFunc) (struct map_session_data **sd, struct item_data **id, int *n, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_equipitem_pos_pre[hIndex].func; - preHookFunc(sd, id, &n, &pos); + preHookFunc(&sd, &id, &n, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54707,10 +54877,10 @@ void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int HPMHooks.source.pc.equipitem_pos(sd, id, n, pos); } if( HPMHooks.count.HP_pc_equipitem_pos_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item_data *id, int *n, int *pos); + void (*postHookFunc) (struct map_session_data *sd, struct item_data *id, int n, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_equipitem_pos_post[hIndex].func; - postHookFunc(sd, id, &n, &pos); + postHookFunc(sd, id, n, pos); } } return; @@ -54719,11 +54889,11 @@ int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_unequipitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *flag); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_unequipitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &flag); + retVal___ = preHookFunc(&sd, &n, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54734,10 +54904,10 @@ int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) { retVal___ = HPMHooks.source.pc.unequipitem(sd, n, flag); } if( HPMHooks.count.HP_pc_unequipitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_unequipitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &flag); + retVal___ = postHookFunc(retVal___, sd, n, flag); } } return retVal___; @@ -54745,11 +54915,11 @@ int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) { void HP_pc_unequipitem_pos(struct map_session_data *sd, int n, int pos) { int hIndex = 0; if( HPMHooks.count.HP_pc_unequipitem_pos_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos); + void (*preHookFunc) (struct map_session_data **sd, int *n, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_unequipitem_pos_pre[hIndex].func; - preHookFunc(sd, &n, &pos); + preHookFunc(&sd, &n, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54760,10 +54930,10 @@ void HP_pc_unequipitem_pos(struct map_session_data *sd, int n, int pos) { HPMHooks.source.pc.unequipitem_pos(sd, n, pos); } if( HPMHooks.count.HP_pc_unequipitem_pos_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *n, int *pos); + void (*postHookFunc) (struct map_session_data *sd, int n, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_unequipitem_pos_post[hIndex].func; - postHookFunc(sd, &n, &pos); + postHookFunc(sd, n, pos); } } return; @@ -54772,11 +54942,11 @@ int HP_pc_checkitem(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkitem_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54799,11 +54969,11 @@ int HP_pc_useitem(struct map_session_data *sd, int n) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_useitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n); + int (*preHookFunc) (struct map_session_data **sd, int *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_useitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n); + retVal___ = preHookFunc(&sd, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54814,10 +54984,10 @@ int HP_pc_useitem(struct map_session_data *sd, int n) { retVal___ = HPMHooks.source.pc.useitem(sd, n); } if( HPMHooks.count.HP_pc_useitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_useitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n); + retVal___ = postHookFunc(retVal___, sd, n); } } return retVal___; @@ -54826,11 +54996,11 @@ int HP_pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_skillatk_bonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillatk_bonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_skillatk_bonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54841,10 +55011,10 @@ int HP_pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.pc.skillatk_bonus(sd, skill_id); } if( HPMHooks.count.HP_pc_skillatk_bonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillatk_bonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_skillatk_bonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -54853,11 +55023,11 @@ int HP_pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_skillheal_bonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal_bonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_skillheal_bonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54868,10 +55038,10 @@ int HP_pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.pc.skillheal_bonus(sd, skill_id); } if( HPMHooks.count.HP_pc_skillheal_bonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal_bonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_skillheal_bonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -54880,11 +55050,11 @@ int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_skillheal2_bonus_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal2_bonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_skillheal2_bonus_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54895,10 +55065,10 @@ int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.pc.skillheal2_bonus(sd, skill_id); } if( HPMHooks.count.HP_pc_skillheal2_bonus_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal2_bonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_skillheal2_bonus_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -54906,11 +55076,11 @@ int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) { void HP_pc_damage(struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp) { int hIndex = 0; if( HPMHooks.count.HP_pc_damage_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *hp, unsigned int *sp); + void (*preHookFunc) (struct map_session_data **sd, struct block_list **src, unsigned int *hp, unsigned int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_damage_pre[hIndex].func; - preHookFunc(sd, src, &hp, &sp); + preHookFunc(&sd, &src, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54921,10 +55091,10 @@ void HP_pc_damage(struct map_session_data *sd, struct block_list *src, unsigned HPMHooks.source.pc.damage(sd, src, hp, sp); } if( HPMHooks.count.HP_pc_damage_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *hp, unsigned int *sp); + void (*postHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_damage_post[hIndex].func; - postHookFunc(sd, src, &hp, &sp); + postHookFunc(sd, src, hp, sp); } } return; @@ -54933,11 +55103,11 @@ int HP_pc_dead(struct map_session_data *sd, struct block_list *src) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_dead_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *src); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_dead_pre[hIndex].func; - retVal___ = preHookFunc(sd, src); + retVal___ = preHookFunc(&sd, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54959,11 +55129,11 @@ int HP_pc_dead(struct map_session_data *sd, struct block_list *src) { void HP_pc_revive(struct map_session_data *sd, unsigned int hp, unsigned int sp) { int hIndex = 0; if( HPMHooks.count.HP_pc_revive_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_revive_pre[hIndex].func; - preHookFunc(sd, &hp, &sp); + preHookFunc(&sd, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -54974,10 +55144,10 @@ void HP_pc_revive(struct map_session_data *sd, unsigned int hp, unsigned int sp) HPMHooks.source.pc.revive(sd, hp, sp); } if( HPMHooks.count.HP_pc_revive_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp); + void (*postHookFunc) (struct map_session_data *sd, unsigned int hp, unsigned int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_revive_post[hIndex].func; - postHookFunc(sd, &hp, &sp); + postHookFunc(sd, hp, sp); } } return; @@ -54985,11 +55155,11 @@ void HP_pc_revive(struct map_session_data *sd, unsigned int hp, unsigned int sp) void HP_pc_heal(struct map_session_data *sd, unsigned int hp, unsigned int sp, int type) { int hIndex = 0; if( HPMHooks.count.HP_pc_heal_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp, int *type); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_heal_pre[hIndex].func; - preHookFunc(sd, &hp, &sp, &type); + preHookFunc(&sd, &hp, &sp, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55000,10 +55170,10 @@ void HP_pc_heal(struct map_session_data *sd, unsigned int hp, unsigned int sp, i HPMHooks.source.pc.heal(sd, hp, sp, type); } if( HPMHooks.count.HP_pc_heal_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp, int *type); + void (*postHookFunc) (struct map_session_data *sd, unsigned int hp, unsigned int sp, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_heal_post[hIndex].func; - postHookFunc(sd, &hp, &sp, &type); + postHookFunc(sd, hp, sp, type); } } return; @@ -55012,11 +55182,11 @@ int HP_pc_itemheal(struct map_session_data *sd, int itemid, int hp, int sp) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_itemheal_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *itemid, int *hp, int *sp); + int (*preHookFunc) (struct map_session_data **sd, int *itemid, int *hp, int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemheal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_itemheal_pre[hIndex].func; - retVal___ = preHookFunc(sd, &itemid, &hp, &sp); + retVal___ = preHookFunc(&sd, &itemid, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55027,10 +55197,10 @@ int HP_pc_itemheal(struct map_session_data *sd, int itemid, int hp, int sp) { retVal___ = HPMHooks.source.pc.itemheal(sd, itemid, hp, sp); } if( HPMHooks.count.HP_pc_itemheal_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *itemid, int *hp, int *sp); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int itemid, int hp, int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemheal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_itemheal_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &itemid, &hp, &sp); + retVal___ = postHookFunc(retVal___, sd, itemid, hp, sp); } } return retVal___; @@ -55039,11 +55209,11 @@ int HP_pc_percentheal(struct map_session_data *sd, int hp, int sp) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_percentheal_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *hp, int *sp); + int (*preHookFunc) (struct map_session_data **sd, int *hp, int *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_percentheal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_percentheal_pre[hIndex].func; - retVal___ = preHookFunc(sd, &hp, &sp); + retVal___ = preHookFunc(&sd, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55054,10 +55224,10 @@ int HP_pc_percentheal(struct map_session_data *sd, int hp, int sp) { retVal___ = HPMHooks.source.pc.percentheal(sd, hp, sp); } if( HPMHooks.count.HP_pc_percentheal_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *hp, int *sp); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int hp, int sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_percentheal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_percentheal_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &hp, &sp); + retVal___ = postHookFunc(retVal___, sd, hp, sp); } } return retVal___; @@ -55066,11 +55236,11 @@ int HP_pc_jobchange(struct map_session_data *sd, int job, int upper) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_jobchange_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *job, int *upper); + int (*preHookFunc) (struct map_session_data **sd, int *job, int *upper); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_jobchange_pre[hIndex].func; - retVal___ = preHookFunc(sd, &job, &upper); + retVal___ = preHookFunc(&sd, &job, &upper); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55081,10 +55251,10 @@ int HP_pc_jobchange(struct map_session_data *sd, int job, int upper) { retVal___ = HPMHooks.source.pc.jobchange(sd, job, upper); } if( HPMHooks.count.HP_pc_jobchange_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *job, int *upper); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int job, int upper); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_jobchange_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &job, &upper); + retVal___ = postHookFunc(retVal___, sd, job, upper); } } return retVal___; @@ -55093,11 +55263,11 @@ int HP_pc_setoption(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setoption_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setoption_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55108,10 +55278,10 @@ int HP_pc_setoption(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.setoption(sd, type); } if( HPMHooks.count.HP_pc_setoption_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setoption_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -55120,11 +55290,11 @@ int HP_pc_setcart(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setcart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setcart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55135,10 +55305,10 @@ int HP_pc_setcart(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.setcart(sd, type); } if( HPMHooks.count.HP_pc_setcart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setcart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -55146,11 +55316,11 @@ int HP_pc_setcart(struct map_session_data *sd, int type) { void HP_pc_setfalcon(struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_pc_setfalcon_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setfalcon_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55161,10 +55331,10 @@ void HP_pc_setfalcon(struct map_session_data *sd, bool flag) { HPMHooks.source.pc.setfalcon(sd, flag); } if( HPMHooks.count.HP_pc_setfalcon_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setfalcon_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -55172,11 +55342,11 @@ void HP_pc_setfalcon(struct map_session_data *sd, bool flag) { void HP_pc_setridingpeco(struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_pc_setridingpeco_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingpeco_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setridingpeco_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55187,10 +55357,10 @@ void HP_pc_setridingpeco(struct map_session_data *sd, bool flag) { HPMHooks.source.pc.setridingpeco(sd, flag); } if( HPMHooks.count.HP_pc_setridingpeco_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingpeco_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setridingpeco_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -55198,11 +55368,11 @@ void HP_pc_setridingpeco(struct map_session_data *sd, bool flag) { void HP_pc_setmadogear(struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_pc_setmadogear_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setmadogear_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55213,10 +55383,10 @@ void HP_pc_setmadogear(struct map_session_data *sd, bool flag) { HPMHooks.source.pc.setmadogear(sd, flag); } if( HPMHooks.count.HP_pc_setmadogear_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setmadogear_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -55224,11 +55394,11 @@ void HP_pc_setmadogear(struct map_session_data *sd, bool flag) { void HP_pc_setridingdragon(struct map_session_data *sd, unsigned int type) { int hIndex = 0; if( HPMHooks.count.HP_pc_setridingdragon_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *type); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingdragon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setridingdragon_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55239,10 +55409,10 @@ void HP_pc_setridingdragon(struct map_session_data *sd, unsigned int type) { HPMHooks.source.pc.setridingdragon(sd, type); } if( HPMHooks.count.HP_pc_setridingdragon_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *type); + void (*postHookFunc) (struct map_session_data *sd, unsigned int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingdragon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setridingdragon_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -55250,11 +55420,11 @@ void HP_pc_setridingdragon(struct map_session_data *sd, unsigned int type) { void HP_pc_setridingwug(struct map_session_data *sd, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_pc_setridingwug_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *flag); + void (*preHookFunc) (struct map_session_data **sd, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingwug_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setridingwug_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55265,10 +55435,10 @@ void HP_pc_setridingwug(struct map_session_data *sd, bool flag) { HPMHooks.source.pc.setridingwug(sd, flag); } if( HPMHooks.count.HP_pc_setridingwug_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *flag); + void (*postHookFunc) (struct map_session_data *sd, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingwug_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setridingwug_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -55277,11 +55447,11 @@ int HP_pc_changelook(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_changelook_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_changelook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_changelook_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55292,10 +55462,10 @@ int HP_pc_changelook(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.changelook(sd, type, val); } if( HPMHooks.count.HP_pc_changelook_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_changelook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_changelook_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -55304,11 +55474,11 @@ int HP_pc_equiplookall(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_equiplookall_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equiplookall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_equiplookall_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55331,11 +55501,11 @@ int HP_pc_readparam(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_readparam_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readparam_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55346,10 +55516,10 @@ int HP_pc_readparam(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.readparam(sd, type); } if( HPMHooks.count.HP_pc_readparam_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readparam_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -55358,11 +55528,11 @@ int HP_pc_setparam(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setparam_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setparam_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setparam_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55373,10 +55543,10 @@ int HP_pc_setparam(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.setparam(sd, type, val); } if( HPMHooks.count.HP_pc_setparam_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setparam_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setparam_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -55385,11 +55555,11 @@ int HP_pc_readreg(struct map_session_data *sd, int64 reg) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_readreg_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int64 *reg); + int (*preHookFunc) (struct map_session_data **sd, int64 *reg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readreg_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®); + retVal___ = preHookFunc(&sd, ®); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55400,10 +55570,10 @@ int HP_pc_readreg(struct map_session_data *sd, int64 reg) { retVal___ = HPMHooks.source.pc.readreg(sd, reg); } if( HPMHooks.count.HP_pc_readreg_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 *reg); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readreg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®); + retVal___ = postHookFunc(retVal___, sd, reg); } } return retVal___; @@ -55411,11 +55581,11 @@ int HP_pc_readreg(struct map_session_data *sd, int64 reg) { void HP_pc_setreg(struct map_session_data *sd, int64 reg, int val) { int hIndex = 0; if( HPMHooks.count.HP_pc_setreg_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int64 *reg, int *val); + void (*preHookFunc) (struct map_session_data **sd, int64 *reg, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setreg_pre[hIndex].func; - preHookFunc(sd, ®, &val); + preHookFunc(&sd, ®, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55426,10 +55596,10 @@ void HP_pc_setreg(struct map_session_data *sd, int64 reg, int val) { HPMHooks.source.pc.setreg(sd, reg, val); } if( HPMHooks.count.HP_pc_setreg_post ) { - void (*postHookFunc) (struct map_session_data *sd, int64 *reg, int *val); + void (*postHookFunc) (struct map_session_data *sd, int64 reg, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setreg_post[hIndex].func; - postHookFunc(sd, ®, &val); + postHookFunc(sd, reg, val); } } return; @@ -55438,11 +55608,11 @@ char* HP_pc_readregstr(struct map_session_data *sd, int64 reg) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_pc_readregstr_pre ) { - char* (*preHookFunc) (struct map_session_data *sd, int64 *reg); + char* (*preHookFunc) (struct map_session_data **sd, int64 *reg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readregstr_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®); + retVal___ = preHookFunc(&sd, ®); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55453,10 +55623,10 @@ char* HP_pc_readregstr(struct map_session_data *sd, int64 reg) { retVal___ = HPMHooks.source.pc.readregstr(sd, reg); } if( HPMHooks.count.HP_pc_readregstr_post ) { - char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 *reg); + char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 reg); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readregstr_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®); + retVal___ = postHookFunc(retVal___, sd, reg); } } return retVal___; @@ -55464,11 +55634,11 @@ char* HP_pc_readregstr(struct map_session_data *sd, int64 reg) { void HP_pc_setregstr(struct map_session_data *sd, int64 reg, const char *str) { int hIndex = 0; if( HPMHooks.count.HP_pc_setregstr_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int64 *reg, const char *str); + void (*preHookFunc) (struct map_session_data **sd, int64 *reg, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setregstr_pre[hIndex].func; - preHookFunc(sd, ®, str); + preHookFunc(&sd, ®, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55479,10 +55649,10 @@ void HP_pc_setregstr(struct map_session_data *sd, int64 reg, const char *str) { HPMHooks.source.pc.setregstr(sd, reg, str); } if( HPMHooks.count.HP_pc_setregstr_post ) { - void (*postHookFunc) (struct map_session_data *sd, int64 *reg, const char *str); + void (*postHookFunc) (struct map_session_data *sd, int64 reg, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setregstr_post[hIndex].func; - postHookFunc(sd, ®, str); + postHookFunc(sd, reg, str); } } return; @@ -55491,11 +55661,11 @@ int HP_pc_readregistry(struct map_session_data *sd, int64 reg) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_readregistry_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int64 *reg); + int (*preHookFunc) (struct map_session_data **sd, int64 *reg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readregistry_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®); + retVal___ = preHookFunc(&sd, ®); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55506,10 +55676,10 @@ int HP_pc_readregistry(struct map_session_data *sd, int64 reg) { retVal___ = HPMHooks.source.pc.readregistry(sd, reg); } if( HPMHooks.count.HP_pc_readregistry_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 *reg); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readregistry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®); + retVal___ = postHookFunc(retVal___, sd, reg); } } return retVal___; @@ -55518,11 +55688,11 @@ int HP_pc_setregistry(struct map_session_data *sd, int64 reg, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setregistry_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int64 *reg, int *val); + int (*preHookFunc) (struct map_session_data **sd, int64 *reg, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setregistry_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®, &val); + retVal___ = preHookFunc(&sd, ®, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55533,10 +55703,10 @@ int HP_pc_setregistry(struct map_session_data *sd, int64 reg, int val) { retVal___ = HPMHooks.source.pc.setregistry(sd, reg, val); } if( HPMHooks.count.HP_pc_setregistry_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 *reg, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setregistry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®, &val); + retVal___ = postHookFunc(retVal___, sd, reg, val); } } return retVal___; @@ -55545,11 +55715,11 @@ char* HP_pc_readregistry_str(struct map_session_data *sd, int64 reg) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_pc_readregistry_str_pre ) { - char* (*preHookFunc) (struct map_session_data *sd, int64 *reg); + char* (*preHookFunc) (struct map_session_data **sd, int64 *reg); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readregistry_str_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®); + retVal___ = preHookFunc(&sd, ®); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55560,10 +55730,10 @@ char* HP_pc_readregistry_str(struct map_session_data *sd, int64 reg) { retVal___ = HPMHooks.source.pc.readregistry_str(sd, reg); } if( HPMHooks.count.HP_pc_readregistry_str_post ) { - char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 *reg); + char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 reg); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readregistry_str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®); + retVal___ = postHookFunc(retVal___, sd, reg); } } return retVal___; @@ -55572,11 +55742,11 @@ int HP_pc_setregistry_str(struct map_session_data *sd, int64 reg, const char *va int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setregistry_str_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int64 *reg, const char *val); + int (*preHookFunc) (struct map_session_data **sd, int64 *reg, const char **val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setregistry_str_pre[hIndex].func; - retVal___ = preHookFunc(sd, ®, val); + retVal___ = preHookFunc(&sd, ®, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55587,10 +55757,10 @@ int HP_pc_setregistry_str(struct map_session_data *sd, int64 reg, const char *va retVal___ = HPMHooks.source.pc.setregistry_str(sd, reg, val); } if( HPMHooks.count.HP_pc_setregistry_str_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 *reg, const char *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg, const char *val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setregistry_str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, ®, val); + retVal___ = postHookFunc(retVal___, sd, reg, val); } } return retVal___; @@ -55599,11 +55769,11 @@ int HP_pc_addeventtimer(struct map_session_data *sd, int tick, const char *name) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_addeventtimer_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *tick, const char *name); + int (*preHookFunc) (struct map_session_data **sd, int *tick, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_addeventtimer_pre[hIndex].func; - retVal___ = preHookFunc(sd, &tick, name); + retVal___ = preHookFunc(&sd, &tick, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55614,10 +55784,10 @@ int HP_pc_addeventtimer(struct map_session_data *sd, int tick, const char *name) retVal___ = HPMHooks.source.pc.addeventtimer(sd, tick, name); } if( HPMHooks.count.HP_pc_addeventtimer_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *tick, const char *name); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int tick, const char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_addeventtimer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &tick, name); + retVal___ = postHookFunc(retVal___, sd, tick, name); } } return retVal___; @@ -55626,11 +55796,11 @@ int HP_pc_deleventtimer(struct map_session_data *sd, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_deleventtimer_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name); + int (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_deleventtimer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_deleventtimer_pre[hIndex].func; - retVal___ = preHookFunc(sd, name); + retVal___ = preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55653,11 +55823,11 @@ int HP_pc_cleareventtimer(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_cleareventtimer_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cleareventtimer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_cleareventtimer_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55680,11 +55850,11 @@ int HP_pc_addeventtimercount(struct map_session_data *sd, const char *name, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_addeventtimercount_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name, int *tick); + int (*preHookFunc) (struct map_session_data **sd, const char **name, int *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimercount_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_addeventtimercount_pre[hIndex].func; - retVal___ = preHookFunc(sd, name, &tick); + retVal___ = preHookFunc(&sd, &name, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55695,10 +55865,10 @@ int HP_pc_addeventtimercount(struct map_session_data *sd, const char *name, int retVal___ = HPMHooks.source.pc.addeventtimercount(sd, name, tick); } if( HPMHooks.count.HP_pc_addeventtimercount_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int *tick); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimercount_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_addeventtimercount_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, name, &tick); + retVal___ = postHookFunc(retVal___, sd, name, tick); } } return retVal___; @@ -55707,11 +55877,11 @@ int HP_pc_calc_pvprank(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_calc_pvprank_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calc_pvprank_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55749,10 +55919,10 @@ int HP_pc_calc_pvprank_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.calc_pvprank_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_calc_pvprank_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_calc_pvprank_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -55761,11 +55931,11 @@ int HP_pc_ismarried(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_ismarried_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_ismarried_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_ismarried_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55788,11 +55958,11 @@ int HP_pc_marriage(struct map_session_data *sd, struct map_session_data *dstsd) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_marriage_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **dstsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_marriage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_marriage_pre[hIndex].func; - retVal___ = preHookFunc(sd, dstsd); + retVal___ = preHookFunc(&sd, &dstsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55815,11 +55985,11 @@ int HP_pc_divorce(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_divorce_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_divorce_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_divorce_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55842,11 +56012,11 @@ struct map_session_data* HP_pc_get_partner(struct map_session_data *sd) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_pc_get_partner_pre ) { - struct map_session_data* (*preHookFunc) (struct map_session_data *sd); + struct map_session_data* (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_partner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_get_partner_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55869,11 +56039,11 @@ struct map_session_data* HP_pc_get_father(struct map_session_data *sd) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_pc_get_father_pre ) { - struct map_session_data* (*preHookFunc) (struct map_session_data *sd); + struct map_session_data* (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_father_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_get_father_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55896,11 +56066,11 @@ struct map_session_data* HP_pc_get_mother(struct map_session_data *sd) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_pc_get_mother_pre ) { - struct map_session_data* (*preHookFunc) (struct map_session_data *sd); + struct map_session_data* (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_mother_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_get_mother_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55923,11 +56093,11 @@ struct map_session_data* HP_pc_get_child(struct map_session_data *sd) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_pc_get_child_pre ) { - struct map_session_data* (*preHookFunc) (struct map_session_data *sd); + struct map_session_data* (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_child_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_get_child_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55949,11 +56119,11 @@ struct map_session_data* HP_pc_get_child(struct map_session_data *sd) { void HP_pc_bleeding(struct map_session_data *sd, unsigned int diff_tick) { int hIndex = 0; if( HPMHooks.count.HP_pc_bleeding_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *diff_tick); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *diff_tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bleeding_pre[hIndex].func; - preHookFunc(sd, &diff_tick); + preHookFunc(&sd, &diff_tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55964,10 +56134,10 @@ void HP_pc_bleeding(struct map_session_data *sd, unsigned int diff_tick) { HPMHooks.source.pc.bleeding(sd, diff_tick); } if( HPMHooks.count.HP_pc_bleeding_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *diff_tick); + void (*postHookFunc) (struct map_session_data *sd, unsigned int diff_tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bleeding_post[hIndex].func; - postHookFunc(sd, &diff_tick); + postHookFunc(sd, diff_tick); } } return; @@ -55975,11 +56145,11 @@ void HP_pc_bleeding(struct map_session_data *sd, unsigned int diff_tick) { void HP_pc_regen(struct map_session_data *sd, unsigned int diff_tick) { int hIndex = 0; if( HPMHooks.count.HP_pc_regen_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *diff_tick); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *diff_tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_regen_pre[hIndex].func; - preHookFunc(sd, &diff_tick); + preHookFunc(&sd, &diff_tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -55990,10 +56160,10 @@ void HP_pc_regen(struct map_session_data *sd, unsigned int diff_tick) { HPMHooks.source.pc.regen(sd, diff_tick); } if( HPMHooks.count.HP_pc_regen_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *diff_tick); + void (*postHookFunc) (struct map_session_data *sd, unsigned int diff_tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_regen_post[hIndex].func; - postHookFunc(sd, &diff_tick); + postHookFunc(sd, diff_tick); } } return; @@ -56001,11 +56171,11 @@ void HP_pc_regen(struct map_session_data *sd, unsigned int diff_tick) { void HP_pc_setstand(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_setstand_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstand_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setstand_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56028,11 +56198,11 @@ int HP_pc_candrop(struct map_session_data *sd, struct item *item) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_candrop_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item *item); + int (*preHookFunc) (struct map_session_data **sd, struct item **item); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_candrop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_candrop_pre[hIndex].func; - retVal___ = preHookFunc(sd, item); + retVal___ = preHookFunc(&sd, &item); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56070,10 +56240,10 @@ int HP_pc_jobid2mapid(unsigned short b_class) { retVal___ = HPMHooks.source.pc.jobid2mapid(b_class); } if( HPMHooks.count.HP_pc_jobid2mapid_post ) { - int (*postHookFunc) (int retVal___, unsigned short *b_class); + int (*postHookFunc) (int retVal___, unsigned short b_class); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobid2mapid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_jobid2mapid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &b_class); + retVal___ = postHookFunc(retVal___, b_class); } } return retVal___; @@ -56097,10 +56267,10 @@ int HP_pc_mapid2jobid(unsigned short class_, int sex) { retVal___ = HPMHooks.source.pc.mapid2jobid(class_, sex); } if( HPMHooks.count.HP_pc_mapid2jobid_post ) { - int (*postHookFunc) (int retVal___, unsigned short *class_, int *sex); + int (*postHookFunc) (int retVal___, unsigned short class_, int sex); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_mapid2jobid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_mapid2jobid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_, &sex); + retVal___ = postHookFunc(retVal___, class_, sex); } } return retVal___; @@ -56124,10 +56294,10 @@ const char* HP_pc_job_name(int class_) { retVal___ = HPMHooks.source.pc.job_name(class_); } if( HPMHooks.count.HP_pc_job_name_post ) { - const char* (*postHookFunc) (const char* retVal___, int *class_); + const char* (*postHookFunc) (const char* retVal___, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_job_name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_job_name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -56135,11 +56305,11 @@ const char* HP_pc_job_name(int class_) { void HP_pc_setinvincibletimer(struct map_session_data *sd, int val) { int hIndex = 0; if( HPMHooks.count.HP_pc_setinvincibletimer_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *val); + void (*preHookFunc) (struct map_session_data **sd, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_pre[hIndex].func; - preHookFunc(sd, &val); + preHookFunc(&sd, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56150,10 +56320,10 @@ void HP_pc_setinvincibletimer(struct map_session_data *sd, int val) { HPMHooks.source.pc.setinvincibletimer(sd, val); } if( HPMHooks.count.HP_pc_setinvincibletimer_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *val); + void (*postHookFunc) (struct map_session_data *sd, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_post[hIndex].func; - postHookFunc(sd, &val); + postHookFunc(sd, val); } } return; @@ -56161,11 +56331,11 @@ void HP_pc_setinvincibletimer(struct map_session_data *sd, int val) { void HP_pc_delinvincibletimer(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_delinvincibletimer_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delinvincibletimer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_delinvincibletimer_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56188,11 +56358,11 @@ int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_addspiritball_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *interval, int *max); + int (*preHookFunc) (struct map_session_data **sd, int *interval, int *max); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_addspiritball_pre[hIndex].func; - retVal___ = preHookFunc(sd, &interval, &max); + retVal___ = preHookFunc(&sd, &interval, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56203,10 +56373,10 @@ int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) { retVal___ = HPMHooks.source.pc.addspiritball(sd, interval, max); } if( HPMHooks.count.HP_pc_addspiritball_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *interval, int *max); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int interval, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_addspiritball_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &interval, &max); + retVal___ = postHookFunc(retVal___, sd, interval, max); } } return retVal___; @@ -56215,11 +56385,11 @@ int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_delspiritball_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *count, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *count, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_delspiritball_pre[hIndex].func; - retVal___ = preHookFunc(sd, &count, &type); + retVal___ = preHookFunc(&sd, &count, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56230,10 +56400,10 @@ int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) { retVal___ = HPMHooks.source.pc.delspiritball(sd, count, type); } if( HPMHooks.count.HP_pc_delspiritball_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *count, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int count, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_delspiritball_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &count, &type); + retVal___ = postHookFunc(retVal___, sd, count, type); } } return retVal___; @@ -56242,11 +56412,11 @@ int HP_pc_getmaxspiritball(struct map_session_data *sd, int min) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_getmaxspiritball_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *min); + int (*preHookFunc) (struct map_session_data **sd, int *min); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getmaxspiritball_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_getmaxspiritball_pre[hIndex].func; - retVal___ = preHookFunc(sd, &min); + retVal___ = preHookFunc(&sd, &min); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56257,10 +56427,10 @@ int HP_pc_getmaxspiritball(struct map_session_data *sd, int min) { retVal___ = HPMHooks.source.pc.getmaxspiritball(sd, min); } if( HPMHooks.count.HP_pc_getmaxspiritball_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *min); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int min); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getmaxspiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_getmaxspiritball_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &min); + retVal___ = postHookFunc(retVal___, sd, min); } } return retVal___; @@ -56268,11 +56438,11 @@ int HP_pc_getmaxspiritball(struct map_session_data *sd, int min) { void HP_pc_addfame(struct map_session_data *sd, int count) { int hIndex = 0; if( HPMHooks.count.HP_pc_addfame_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *count); + void (*preHookFunc) (struct map_session_data **sd, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_addfame_pre[hIndex].func; - preHookFunc(sd, &count); + preHookFunc(&sd, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56283,10 +56453,10 @@ void HP_pc_addfame(struct map_session_data *sd, int count) { HPMHooks.source.pc.addfame(sd, count); } if( HPMHooks.count.HP_pc_addfame_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *count); + void (*postHookFunc) (struct map_session_data *sd, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_addfame_post[hIndex].func; - postHookFunc(sd, &count); + postHookFunc(sd, count); } } return; @@ -56310,10 +56480,10 @@ unsigned char HP_pc_famerank(int char_id, int job) { retVal___ = HPMHooks.source.pc.famerank(char_id, job); } if( HPMHooks.count.HP_pc_famerank_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, int *char_id, int *job); + unsigned char (*postHookFunc) (unsigned char retVal___, int char_id, int job); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_famerank_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_famerank_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &char_id, &job); + retVal___ = postHookFunc(retVal___, char_id, job); } } return retVal___; @@ -56322,11 +56492,11 @@ int HP_pc_set_hate_mob(struct map_session_data *sd, int pos, struct block_list * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_set_hate_mob_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *pos, struct block_list *bl); + int (*preHookFunc) (struct map_session_data **sd, int *pos, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_hate_mob_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_set_hate_mob_pre[hIndex].func; - retVal___ = preHookFunc(sd, &pos, bl); + retVal___ = preHookFunc(&sd, &pos, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56337,10 +56507,10 @@ int HP_pc_set_hate_mob(struct map_session_data *sd, int pos, struct block_list * retVal___ = HPMHooks.source.pc.set_hate_mob(sd, pos, bl); } if( HPMHooks.count.HP_pc_set_hate_mob_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos, struct block_list *bl); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos, struct block_list *bl); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_hate_mob_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_set_hate_mob_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &pos, bl); + retVal___ = postHookFunc(retVal___, sd, pos, bl); } } return retVal___; @@ -56391,10 +56561,10 @@ int HP_pc_map_day_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.map_day_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_map_day_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_day_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_map_day_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -56418,10 +56588,10 @@ int HP_pc_map_night_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.map_night_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_map_night_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_night_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_map_night_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -56429,11 +56599,11 @@ int HP_pc_map_night_timer(int tid, int64 tick, int id, intptr_t data) { void HP_pc_inventory_rentals(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_inventory_rentals_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rentals_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_inventory_rentals_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56456,11 +56626,11 @@ int HP_pc_inventory_rental_clear(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_inventory_rental_clear_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_inventory_rental_clear_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56482,11 +56652,11 @@ int HP_pc_inventory_rental_clear(struct map_session_data *sd) { void HP_pc_inventory_rental_add(struct map_session_data *sd, int seconds) { int hIndex = 0; if( HPMHooks.count.HP_pc_inventory_rental_add_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *seconds); + void (*preHookFunc) (struct map_session_data **sd, int *seconds); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_inventory_rental_add_pre[hIndex].func; - preHookFunc(sd, &seconds); + preHookFunc(&sd, &seconds); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56497,10 +56667,10 @@ void HP_pc_inventory_rental_add(struct map_session_data *sd, int seconds) { HPMHooks.source.pc.inventory_rental_add(sd, seconds); } if( HPMHooks.count.HP_pc_inventory_rental_add_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *seconds); + void (*postHookFunc) (struct map_session_data *sd, int seconds); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_inventory_rental_add_post[hIndex].func; - postHookFunc(sd, &seconds); + postHookFunc(sd, seconds); } } return; @@ -56509,11 +56679,11 @@ int HP_pc_disguise(struct map_session_data *sd, int class_) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_disguise_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *class_); + int (*preHookFunc) (struct map_session_data **sd, int *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_disguise_pre[hIndex].func; - retVal___ = preHookFunc(sd, &class_); + retVal___ = preHookFunc(&sd, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56524,10 +56694,10 @@ int HP_pc_disguise(struct map_session_data *sd, int class_) { retVal___ = HPMHooks.source.pc.disguise(sd, class_); } if( HPMHooks.count.HP_pc_disguise_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_disguise_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &class_); + retVal___ = postHookFunc(retVal___, sd, class_); } } return retVal___; @@ -56536,11 +56706,11 @@ bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_isautolooting_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *nameid); + bool (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_isautolooting_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56551,10 +56721,10 @@ bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.pc.isautolooting(sd, nameid); } if( HPMHooks.count.HP_pc_isautolooting_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *nameid); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_isautolooting_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -56562,11 +56732,11 @@ bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) { void HP_pc_overheat(struct map_session_data *sd, int val) { int hIndex = 0; if( HPMHooks.count.HP_pc_overheat_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *val); + void (*preHookFunc) (struct map_session_data **sd, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_overheat_pre[hIndex].func; - preHookFunc(sd, &val); + preHookFunc(&sd, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56577,10 +56747,10 @@ void HP_pc_overheat(struct map_session_data *sd, int val) { HPMHooks.source.pc.overheat(sd, val); } if( HPMHooks.count.HP_pc_overheat_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *val); + void (*postHookFunc) (struct map_session_data *sd, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_overheat_post[hIndex].func; - postHookFunc(sd, &val); + postHookFunc(sd, val); } } return; @@ -56589,11 +56759,11 @@ int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_banding_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_banding_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_banding_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56604,10 +56774,10 @@ int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) { retVal___ = HPMHooks.source.pc.banding(sd, skill_lv); } if( HPMHooks.count.HP_pc_banding_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_banding_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_banding_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_lv); } } return retVal___; @@ -56615,11 +56785,11 @@ int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) { void HP_pc_itemcd_do(struct map_session_data *sd, bool load) { int hIndex = 0; if( HPMHooks.count.HP_pc_itemcd_do_pre ) { - void (*preHookFunc) (struct map_session_data *sd, bool *load); + void (*preHookFunc) (struct map_session_data **sd, bool *load); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemcd_do_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_itemcd_do_pre[hIndex].func; - preHookFunc(sd, &load); + preHookFunc(&sd, &load); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56630,10 +56800,10 @@ void HP_pc_itemcd_do(struct map_session_data *sd, bool load) { HPMHooks.source.pc.itemcd_do(sd, load); } if( HPMHooks.count.HP_pc_itemcd_do_post ) { - void (*postHookFunc) (struct map_session_data *sd, bool *load); + void (*postHookFunc) (struct map_session_data *sd, bool load); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemcd_do_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_itemcd_do_post[hIndex].func; - postHookFunc(sd, &load); + postHookFunc(sd, load); } } return; @@ -56642,11 +56812,11 @@ int HP_pc_load_combo(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_load_combo_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_load_combo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_load_combo_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56668,11 +56838,11 @@ int HP_pc_load_combo(struct map_session_data *sd) { void HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int type) { int hIndex = 0; if( HPMHooks.count.HP_pc_add_charm_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *interval, int *max, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *interval, int *max, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_add_charm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_add_charm_pre[hIndex].func; - preHookFunc(sd, &interval, &max, &type); + preHookFunc(&sd, &interval, &max, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56683,10 +56853,10 @@ void HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int typ HPMHooks.source.pc.add_charm(sd, interval, max, type); } if( HPMHooks.count.HP_pc_add_charm_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *interval, int *max, int *type); + void (*postHookFunc) (struct map_session_data *sd, int interval, int max, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_add_charm_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_add_charm_post[hIndex].func; - postHookFunc(sd, &interval, &max, &type); + postHookFunc(sd, interval, max, type); } } return; @@ -56694,11 +56864,11 @@ void HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int typ void HP_pc_del_charm(struct map_session_data *sd, int count, int type) { int hIndex = 0; if( HPMHooks.count.HP_pc_del_charm_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *count, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *count, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_del_charm_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_del_charm_pre[hIndex].func; - preHookFunc(sd, &count, &type); + preHookFunc(&sd, &count, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56709,10 +56879,10 @@ void HP_pc_del_charm(struct map_session_data *sd, int count, int type) { HPMHooks.source.pc.del_charm(sd, count, type); } if( HPMHooks.count.HP_pc_del_charm_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *count, int *type); + void (*postHookFunc) (struct map_session_data *sd, int count, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_del_charm_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_del_charm_post[hIndex].func; - postHookFunc(sd, &count, &type); + postHookFunc(sd, count, type); } } return; @@ -56720,11 +56890,11 @@ void HP_pc_del_charm(struct map_session_data *sd, int count, int type) { void HP_pc_baselevelchanged(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_baselevelchanged_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_baselevelchanged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_baselevelchanged_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56762,10 +56932,10 @@ int HP_pc_level_penalty_mod(int diff, unsigned char race, uint32 mode, int type) retVal___ = HPMHooks.source.pc.level_penalty_mod(diff, race, mode, type); } if( HPMHooks.count.HP_pc_level_penalty_mod_post ) { - int (*postHookFunc) (int retVal___, int *diff, unsigned char *race, uint32 *mode, int *type); + int (*postHookFunc) (int retVal___, int diff, unsigned char race, uint32 mode, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_level_penalty_mod_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_level_penalty_mod_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &diff, &race, &mode, &type); + retVal___ = postHookFunc(retVal___, diff, race, mode, type); } } return retVal___; @@ -56774,11 +56944,11 @@ int HP_pc_calc_skillpoint(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_calc_skillpoint_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skillpoint_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calc_skillpoint_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56816,10 +56986,10 @@ int HP_pc_invincible_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.invincible_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_invincible_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_invincible_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_invincible_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -56843,10 +57013,10 @@ int HP_pc_spiritball_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.spiritball_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_spiritball_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_spiritball_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_spiritball_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -56855,12 +57025,12 @@ int HP_pc_check_banding(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_check_banding_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_banding_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pc_check_banding_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -56903,10 +57073,10 @@ int HP_pc_inventory_rental_end(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.inventory_rental_end(tid, tick, id, data); } if( HPMHooks.count.HP_pc_inventory_rental_end_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_inventory_rental_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -56914,11 +57084,11 @@ int HP_pc_inventory_rental_end(int tid, int64 tick, int id, intptr_t data) { void HP_pc_check_skilltree(struct map_session_data *sd, int skill_id) { int hIndex = 0; if( HPMHooks.count.HP_pc_check_skilltree_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *skill_id); + void (*preHookFunc) (struct map_session_data **sd, int *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_skilltree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_check_skilltree_pre[hIndex].func; - preHookFunc(sd, &skill_id); + preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56929,10 +57099,10 @@ void HP_pc_check_skilltree(struct map_session_data *sd, int skill_id) { HPMHooks.source.pc.check_skilltree(sd, skill_id); } if( HPMHooks.count.HP_pc_check_skilltree_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *skill_id); + void (*postHookFunc) (struct map_session_data *sd, int skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_skilltree_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_check_skilltree_post[hIndex].func; - postHookFunc(sd, &skill_id); + postHookFunc(sd, skill_id); } } return; @@ -56941,11 +57111,11 @@ int HP_pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_autospell_pre ) { - int (*preHookFunc) (struct s_autospell *spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id); + int (*preHookFunc) (struct s_autospell **spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_autospell_pre[hIndex].func; - retVal___ = preHookFunc(spell, &max, &id, &lv, &rate, &flag, &card_id); + retVal___ = preHookFunc(&spell, &max, &id, &lv, &rate, &flag, &card_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56956,10 +57126,10 @@ int HP_pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv retVal___ = HPMHooks.source.pc.bonus_autospell(spell, max, id, lv, rate, flag, card_id); } if( HPMHooks.count.HP_pc_bonus_autospell_post ) { - int (*postHookFunc) (int retVal___, struct s_autospell *spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id); + int (*postHookFunc) (int retVal___, struct s_autospell *spell, int max, short id, short lv, short rate, short flag, short card_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, spell, &max, &id, &lv, &rate, &flag, &card_id); + retVal___ = postHookFunc(retVal___, spell, max, id, lv, rate, flag, card_id); } } return retVal___; @@ -56968,11 +57138,11 @@ int HP_pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_ int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_autospell_onskill_pre ) { - int (*preHookFunc) (struct s_autospell *spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id); + int (*preHookFunc) (struct s_autospell **spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_onskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_autospell_onskill_pre[hIndex].func; - retVal___ = preHookFunc(spell, &max, &src_skill, &id, &lv, &rate, &card_id); + retVal___ = preHookFunc(&spell, &max, &src_skill, &id, &lv, &rate, &card_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -56983,10 +57153,10 @@ int HP_pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_ retVal___ = HPMHooks.source.pc.bonus_autospell_onskill(spell, max, src_skill, id, lv, rate, card_id); } if( HPMHooks.count.HP_pc_bonus_autospell_onskill_post ) { - int (*postHookFunc) (int retVal___, struct s_autospell *spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id); + int (*postHookFunc) (int retVal___, struct s_autospell *spell, int max, short src_skill, short id, short lv, short rate, short card_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_onskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_onskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, spell, &max, &src_skill, &id, &lv, &rate, &card_id); + retVal___ = postHookFunc(retVal___, spell, max, src_skill, id, lv, rate, card_id); } } return retVal___; @@ -56995,11 +57165,11 @@ int HP_pc_bonus_addeff(struct s_addeffect *effect, int max, enum sc_type id, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_addeff_pre ) { - int (*preHookFunc) (struct s_addeffect *effect, int *max, enum sc_type *id, int16 *rate, int16 *arrow_rate, uint8 *flag, uint16 *duration); + int (*preHookFunc) (struct s_addeffect **effect, int *max, enum sc_type *id, int16 *rate, int16 *arrow_rate, uint8 *flag, uint16 *duration); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_addeff_pre[hIndex].func; - retVal___ = preHookFunc(effect, &max, &id, &rate, &arrow_rate, &flag, &duration); + retVal___ = preHookFunc(&effect, &max, &id, &rate, &arrow_rate, &flag, &duration); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57010,10 +57180,10 @@ int HP_pc_bonus_addeff(struct s_addeffect *effect, int max, enum sc_type id, int retVal___ = HPMHooks.source.pc.bonus_addeff(effect, max, id, rate, arrow_rate, flag, duration); } if( HPMHooks.count.HP_pc_bonus_addeff_post ) { - int (*postHookFunc) (int retVal___, struct s_addeffect *effect, int *max, enum sc_type *id, int16 *rate, int16 *arrow_rate, uint8 *flag, uint16 *duration); + int (*postHookFunc) (int retVal___, struct s_addeffect *effect, int max, enum sc_type id, int16 rate, int16 arrow_rate, uint8 flag, uint16 duration); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_post[hIndex].func; - retVal___ = postHookFunc(retVal___, effect, &max, &id, &rate, &arrow_rate, &flag, &duration); + retVal___ = postHookFunc(retVal___, effect, max, id, rate, arrow_rate, flag, duration); } } return retVal___; @@ -57022,11 +57192,11 @@ int HP_pc_bonus_addeff_onskill(struct s_addeffectonskill *effect, int max, enum int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_addeff_onskill_pre ) { - int (*preHookFunc) (struct s_addeffectonskill *effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target); + int (*preHookFunc) (struct s_addeffectonskill **effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_onskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_addeff_onskill_pre[hIndex].func; - retVal___ = preHookFunc(effect, &max, &id, &rate, &skill_id, &target); + retVal___ = preHookFunc(&effect, &max, &id, &rate, &skill_id, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57037,10 +57207,10 @@ int HP_pc_bonus_addeff_onskill(struct s_addeffectonskill *effect, int max, enum retVal___ = HPMHooks.source.pc.bonus_addeff_onskill(effect, max, id, rate, skill_id, target); } if( HPMHooks.count.HP_pc_bonus_addeff_onskill_post ) { - int (*postHookFunc) (int retVal___, struct s_addeffectonskill *effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target); + int (*postHookFunc) (int retVal___, struct s_addeffectonskill *effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_onskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_onskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, effect, &max, &id, &rate, &skill_id, &target); + retVal___ = postHookFunc(retVal___, effect, max, id, rate, skill_id, target); } } return retVal___; @@ -57049,11 +57219,11 @@ int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, sh int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_bonus_item_drop_pre ) { - int (*preHookFunc) (struct s_add_drop *drop, const short *max, short *id, short *group, int *race, int *rate); + int (*preHookFunc) (struct s_add_drop **drop, const short *max, short *id, short *group, int *race, int *rate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_item_drop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bonus_item_drop_pre[hIndex].func; - retVal___ = preHookFunc(drop, &max, &id, &group, &race, &rate); + retVal___ = preHookFunc(&drop, &max, &id, &group, &race, &rate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57064,10 +57234,10 @@ int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, sh retVal___ = HPMHooks.source.pc.bonus_item_drop(drop, max, id, group, race, rate); } if( HPMHooks.count.HP_pc_bonus_item_drop_post ) { - int (*postHookFunc) (int retVal___, struct s_add_drop *drop, const short *max, short *id, short *group, int *race, int *rate); + int (*postHookFunc) (int retVal___, struct s_add_drop *drop, const short max, short id, short group, int race, int rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_item_drop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bonus_item_drop_post[hIndex].func; - retVal___ = postHookFunc(retVal___, drop, &max, &id, &group, &race, &rate); + retVal___ = postHookFunc(retVal___, drop, max, id, group, race, rate); } } return retVal___; @@ -57075,11 +57245,11 @@ int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, sh void HP_pc_calcexp(struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src) { int hIndex = 0; if( HPMHooks.count.HP_pc_calcexp_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src); + void (*preHookFunc) (struct map_session_data **sd, unsigned int **base_exp, unsigned int **job_exp, struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calcexp_pre[hIndex].func; - preHookFunc(sd, base_exp, job_exp, src); + preHookFunc(&sd, &base_exp, &job_exp, &src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57117,10 +57287,10 @@ int HP_pc_respawn_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.respawn_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_respawn_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_respawn_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57129,12 +57299,12 @@ int HP_pc_jobchange_killclone(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_jobchange_killclone_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_killclone_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pc_jobchange_killclone_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -57162,11 +57332,11 @@ int HP_pc_getstat(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_getstat_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_getstat_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57177,10 +57347,10 @@ int HP_pc_getstat(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pc.getstat(sd, type); } if( HPMHooks.count.HP_pc_getstat_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_getstat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -57189,11 +57359,11 @@ int HP_pc_setstat(struct map_session_data *sd, int type, int val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_setstat_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type, int *val); + int (*preHookFunc) (struct map_session_data **sd, int *type, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstat_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_setstat_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type, &val); + retVal___ = preHookFunc(&sd, &type, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57204,10 +57374,10 @@ int HP_pc_setstat(struct map_session_data *sd, int type, int val) { retVal___ = HPMHooks.source.pc.setstat(sd, type, val); } if( HPMHooks.count.HP_pc_setstat_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstat_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_setstat_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type, &val); + retVal___ = postHookFunc(retVal___, sd, type, val); } } return retVal___; @@ -57231,10 +57401,10 @@ int HP_pc_eventtimer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.eventtimer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_eventtimer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_eventtimer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_eventtimer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57243,12 +57413,12 @@ int HP_pc_daynight_timer_sub(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_daynight_timer_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_daynight_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pc_daynight_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -57291,10 +57461,10 @@ int HP_pc_charm_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.charm_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_charm_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_charm_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_charm_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57303,11 +57473,11 @@ bool HP_pc_readdb_levelpenalty(char *fields[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_pc_readdb_levelpenalty_pre ) { - bool (*preHookFunc) (char *fields[], int *columns, int *current); + bool (*preHookFunc) (char **fields[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_levelpenalty_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_readdb_levelpenalty_pre[hIndex].func; - retVal___ = preHookFunc(fields, &columns, ¤t); + retVal___ = preHookFunc(&fields, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57318,10 +57488,10 @@ bool HP_pc_readdb_levelpenalty(char *fields[], int columns, int current) { retVal___ = HPMHooks.source.pc.readdb_levelpenalty(fields, columns, current); } if( HPMHooks.count.HP_pc_readdb_levelpenalty_post ) { - bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_levelpenalty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_readdb_levelpenalty_post[hIndex].func; - retVal___ = postHookFunc(retVal___, fields, &columns, ¤t); + retVal___ = postHookFunc(retVal___, fields, columns, current); } } return retVal___; @@ -57345,10 +57515,10 @@ int HP_pc_autosave(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.autosave(tid, tick, id, data); } if( HPMHooks.count.HP_pc_autosave_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autosave_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_autosave_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57372,10 +57542,10 @@ int HP_pc_follow_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.follow_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_follow_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_follow_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57436,11 +57606,11 @@ int HP_pc_isUseitem(struct map_session_data *sd, int n) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_isUseitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n); + int (*preHookFunc) (struct map_session_data **sd, int *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_isUseitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n); + retVal___ = preHookFunc(&sd, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57451,10 +57621,10 @@ int HP_pc_isUseitem(struct map_session_data *sd, int n) { retVal___ = HPMHooks.source.pc.isUseitem(sd, n); } if( HPMHooks.count.HP_pc_isUseitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_isUseitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n); + retVal___ = postHookFunc(retVal___, sd, n); } } return retVal___; @@ -57463,12 +57633,12 @@ int HP_pc_show_steal(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_show_steal_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_show_steal_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pc_show_steal_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -57496,11 +57666,11 @@ int HP_pc_checkcombo(struct map_session_data *sd, struct item_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_checkcombo_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item_data *data); + int (*preHookFunc) (struct map_session_data **sd, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkcombo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_checkcombo_pre[hIndex].func; - retVal___ = preHookFunc(sd, data); + retVal___ = preHookFunc(&sd, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57523,11 +57693,11 @@ int HP_pc_calcweapontype(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_calcweapontype_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcweapontype_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_calcweapontype_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57550,11 +57720,11 @@ int HP_pc_removecombo(struct map_session_data *sd, struct item_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_removecombo_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item_data *data); + int (*preHookFunc) (struct map_session_data **sd, struct item_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_removecombo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_removecombo_pre[hIndex].func; - retVal___ = preHookFunc(sd, data); + retVal___ = preHookFunc(&sd, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57576,11 +57746,11 @@ int HP_pc_removecombo(struct map_session_data *sd, struct item_data *data) { void HP_pc_bank_deposit(struct map_session_data *sd, int money) { int hIndex = 0; if( HPMHooks.count.HP_pc_bank_deposit_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *money); + void (*preHookFunc) (struct map_session_data **sd, int *money); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_deposit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bank_deposit_pre[hIndex].func; - preHookFunc(sd, &money); + preHookFunc(&sd, &money); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57591,10 +57761,10 @@ void HP_pc_bank_deposit(struct map_session_data *sd, int money) { HPMHooks.source.pc.bank_deposit(sd, money); } if( HPMHooks.count.HP_pc_bank_deposit_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *money); + void (*postHookFunc) (struct map_session_data *sd, int money); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_deposit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bank_deposit_post[hIndex].func; - postHookFunc(sd, &money); + postHookFunc(sd, money); } } return; @@ -57602,11 +57772,11 @@ void HP_pc_bank_deposit(struct map_session_data *sd, int money) { void HP_pc_bank_withdraw(struct map_session_data *sd, int money) { int hIndex = 0; if( HPMHooks.count.HP_pc_bank_withdraw_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *money); + void (*preHookFunc) (struct map_session_data **sd, int *money); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_withdraw_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bank_withdraw_pre[hIndex].func; - preHookFunc(sd, &money); + preHookFunc(&sd, &money); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57617,10 +57787,10 @@ void HP_pc_bank_withdraw(struct map_session_data *sd, int money) { HPMHooks.source.pc.bank_withdraw(sd, money); } if( HPMHooks.count.HP_pc_bank_withdraw_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *money); + void (*postHookFunc) (struct map_session_data *sd, int money); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_withdraw_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bank_withdraw_post[hIndex].func; - postHookFunc(sd, &money); + postHookFunc(sd, money); } } return; @@ -57628,11 +57798,11 @@ void HP_pc_bank_withdraw(struct map_session_data *sd, int money) { void HP_pc_rental_expire(struct map_session_data *sd, int i) { int hIndex = 0; if( HPMHooks.count.HP_pc_rental_expire_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *i); + void (*preHookFunc) (struct map_session_data **sd, int *i); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_rental_expire_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_rental_expire_pre[hIndex].func; - preHookFunc(sd, &i); + preHookFunc(&sd, &i); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57643,10 +57813,10 @@ void HP_pc_rental_expire(struct map_session_data *sd, int i) { HPMHooks.source.pc.rental_expire(sd, i); } if( HPMHooks.count.HP_pc_rental_expire_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *i); + void (*postHookFunc) (struct map_session_data *sd, int i); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_rental_expire_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_rental_expire_post[hIndex].func; - postHookFunc(sd, &i); + postHookFunc(sd, i); } } return; @@ -57654,11 +57824,11 @@ void HP_pc_rental_expire(struct map_session_data *sd, int i) { void HP_pc_scdata_received(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_scdata_received_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_scdata_received_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_scdata_received_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57680,11 +57850,11 @@ void HP_pc_scdata_received(struct map_session_data *sd) { void HP_pc_bound_clear(struct map_session_data *sd, enum e_item_bound_type type) { int hIndex = 0; if( HPMHooks.count.HP_pc_bound_clear_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_item_bound_type *type); + void (*preHookFunc) (struct map_session_data **sd, enum e_item_bound_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bound_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_bound_clear_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57695,10 +57865,10 @@ void HP_pc_bound_clear(struct map_session_data *sd, enum e_item_bound_type type) HPMHooks.source.pc.bound_clear(sd, type); } if( HPMHooks.count.HP_pc_bound_clear_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_item_bound_type *type); + void (*postHookFunc) (struct map_session_data *sd, enum e_item_bound_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bound_clear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_bound_clear_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -57722,10 +57892,10 @@ int HP_pc_expiration_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.expiration_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_expiration_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expiration_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_expiration_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57749,10 +57919,10 @@ int HP_pc_global_expiration_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pc.global_expiration_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pc_global_expiration_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_global_expiration_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_global_expiration_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -57760,11 +57930,11 @@ int HP_pc_global_expiration_timer(int tid, int64 tick, int id, intptr_t data) { void HP_pc_expire_check(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_expire_check_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expire_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_expire_check_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57802,10 +57972,10 @@ bool HP_pc_db_checkid(unsigned int class_) { retVal___ = HPMHooks.source.pc.db_checkid(class_); } if( HPMHooks.count.HP_pc_db_checkid_post ) { - bool (*postHookFunc) (bool retVal___, unsigned int *class_); + bool (*postHookFunc) (bool retVal___, unsigned int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_db_checkid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_db_checkid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &class_); + retVal___ = postHookFunc(retVal___, class_); } } return retVal___; @@ -57865,11 +58035,11 @@ void HP_pc_autotrade_load(void) { void HP_pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_update_action action) { int hIndex = 0; if( HPMHooks.count.HP_pc_autotrade_update_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_pc_autotrade_update_action *action); + void (*preHookFunc) (struct map_session_data **sd, enum e_pc_autotrade_update_action *action); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_autotrade_update_pre[hIndex].func; - preHookFunc(sd, &action); + preHookFunc(&sd, &action); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57880,10 +58050,10 @@ void HP_pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_upd HPMHooks.source.pc.autotrade_update(sd, action); } if( HPMHooks.count.HP_pc_autotrade_update_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_pc_autotrade_update_action *action); + void (*postHookFunc) (struct map_session_data *sd, enum e_pc_autotrade_update_action action); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_autotrade_update_post[hIndex].func; - postHookFunc(sd, &action); + postHookFunc(sd, action); } } return; @@ -57891,11 +58061,11 @@ void HP_pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_upd void HP_pc_autotrade_start(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_autotrade_start_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_autotrade_start_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57917,11 +58087,11 @@ void HP_pc_autotrade_start(struct map_session_data *sd) { void HP_pc_autotrade_prepare(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_autotrade_prepare_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_prepare_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_autotrade_prepare_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57943,11 +58113,11 @@ void HP_pc_autotrade_prepare(struct map_session_data *sd) { void HP_pc_autotrade_populate(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_pc_autotrade_populate_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_populate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_autotrade_populate_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -57970,12 +58140,12 @@ int HP_pc_autotrade_final(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_autotrade_final_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_final_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pc_autotrade_final_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -57989,11 +58159,11 @@ int HP_pc_autotrade_final(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_pc_autotrade_final_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_final_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_pc_autotrade_final_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -58003,11 +58173,11 @@ int HP_pc_check_job_name(const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_check_job_name_pre ) { - int (*preHookFunc) (const char *name); + int (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_job_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_check_job_name_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58029,11 +58199,11 @@ int HP_pc_check_job_name(const char *name) { void HP_pc_update_idle_time(struct map_session_data *sd, enum e_battle_config_idletime type) { int hIndex = 0; if( HPMHooks.count.HP_pc_update_idle_time_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_battle_config_idletime *type); + void (*preHookFunc) (struct map_session_data **sd, enum e_battle_config_idletime *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_update_idle_time_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_update_idle_time_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58044,10 +58214,10 @@ void HP_pc_update_idle_time(struct map_session_data *sd, enum e_battle_config_id HPMHooks.source.pc.update_idle_time(sd, type); } if( HPMHooks.count.HP_pc_update_idle_time_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_battle_config_idletime *type); + void (*postHookFunc) (struct map_session_data *sd, enum e_battle_config_idletime type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_update_idle_time_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pc_update_idle_time_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -58056,11 +58226,11 @@ int HP_pc_have_magnifier(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pc_have_magnifier_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_have_magnifier_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pc_have_magnifier_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58079,16 +58249,69 @@ int HP_pc_have_magnifier(struct map_session_data *sd) { } return retVal___; } +bool HP_pc_process_chat_message(struct map_session_data *sd, const char *message) { + int hIndex = 0; + bool retVal___ = false; + if( HPMHooks.count.HP_pc_process_chat_message_pre ) { + bool (*preHookFunc) (struct map_session_data **sd, const char **message); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_process_chat_message_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pc_process_chat_message_pre[hIndex].func; + retVal___ = preHookFunc(&sd, &message); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.pc.process_chat_message(sd, message); + } + if( HPMHooks.count.HP_pc_process_chat_message_post ) { + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *message); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_process_chat_message_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pc_process_chat_message_post[hIndex].func; + retVal___ = postHookFunc(retVal___, sd, message); + } + } + return retVal___; +} +void HP_pc_check_supernovice_call(struct map_session_data *sd, const char *message) { + int hIndex = 0; + if( HPMHooks.count.HP_pc_check_supernovice_call_pre ) { + void (*preHookFunc) (struct map_session_data **sd, const char **message); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_supernovice_call_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_pc_check_supernovice_call_pre[hIndex].func; + preHookFunc(&sd, &message); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.pc.check_supernovice_call(sd, message); + } + if( HPMHooks.count.HP_pc_check_supernovice_call_post ) { + void (*postHookFunc) (struct map_session_data *sd, const char *message); + for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_supernovice_call_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_pc_check_supernovice_call_post[hIndex].func; + postHookFunc(sd, message); + } + } + return; +} /* pcre_interface */ pcre* HP_libpcre_compile(const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr) { int hIndex = 0; pcre* retVal___ = NULL; if( HPMHooks.count.HP_libpcre_compile_pre ) { - pcre* (*preHookFunc) (const char *pattern, int *options, const char **errptr, int *erroffset, const unsigned char *tableptr); + pcre* (*preHookFunc) (const char **pattern, int *options, const char ***errptr, int **erroffset, const unsigned char **tableptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_compile_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_compile_pre[hIndex].func; - retVal___ = preHookFunc(pattern, &options, errptr, erroffset, tableptr); + retVal___ = preHookFunc(&pattern, &options, &errptr, &erroffset, &tableptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58099,10 +58322,10 @@ pcre* HP_libpcre_compile(const char *pattern, int options, const char **errptr, retVal___ = HPMHooks.source.libpcre.compile(pattern, options, errptr, erroffset, tableptr); } if( HPMHooks.count.HP_libpcre_compile_post ) { - pcre* (*postHookFunc) (pcre* retVal___, const char *pattern, int *options, const char **errptr, int *erroffset, const unsigned char *tableptr); + pcre* (*postHookFunc) (pcre* retVal___, const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_compile_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_compile_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pattern, &options, errptr, erroffset, tableptr); + retVal___ = postHookFunc(retVal___, pattern, options, errptr, erroffset, tableptr); } } return retVal___; @@ -58111,11 +58334,11 @@ pcre_extra* HP_libpcre_study(const pcre *code, int options, const char **errptr) int hIndex = 0; pcre_extra* retVal___ = NULL; if( HPMHooks.count.HP_libpcre_study_pre ) { - pcre_extra* (*preHookFunc) (const pcre *code, int *options, const char **errptr); + pcre_extra* (*preHookFunc) (const pcre **code, int *options, const char ***errptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_study_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_study_pre[hIndex].func; - retVal___ = preHookFunc(code, &options, errptr); + retVal___ = preHookFunc(&code, &options, &errptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58126,10 +58349,10 @@ pcre_extra* HP_libpcre_study(const pcre *code, int options, const char **errptr) retVal___ = HPMHooks.source.libpcre.study(code, options, errptr); } if( HPMHooks.count.HP_libpcre_study_post ) { - pcre_extra* (*postHookFunc) (pcre_extra* retVal___, const pcre *code, int *options, const char **errptr); + pcre_extra* (*postHookFunc) (pcre_extra* retVal___, const pcre *code, int options, const char **errptr); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_study_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_study_post[hIndex].func; - retVal___ = postHookFunc(retVal___, code, &options, errptr); + retVal___ = postHookFunc(retVal___, code, options, errptr); } } return retVal___; @@ -58138,11 +58361,11 @@ int HP_libpcre_exec(const pcre *code, const pcre_extra *extra, PCRE_SPTR subject int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libpcre_exec_pre ) { - int (*preHookFunc) (const pcre *code, const pcre_extra *extra, PCRE_SPTR *subject, int *length, int *startoffset, int *options, int *ovector, int *ovecsize); + int (*preHookFunc) (const pcre **code, const pcre_extra **extra, PCRE_SPTR *subject, int *length, int *startoffset, int *options, int **ovector, int *ovecsize); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_exec_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_exec_pre[hIndex].func; - retVal___ = preHookFunc(code, extra, &subject, &length, &startoffset, &options, ovector, &ovecsize); + retVal___ = preHookFunc(&code, &extra, &subject, &length, &startoffset, &options, &ovector, &ovecsize); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58153,10 +58376,10 @@ int HP_libpcre_exec(const pcre *code, const pcre_extra *extra, PCRE_SPTR subject retVal___ = HPMHooks.source.libpcre.exec(code, extra, subject, length, startoffset, options, ovector, ovecsize); } if( HPMHooks.count.HP_libpcre_exec_post ) { - int (*postHookFunc) (int retVal___, const pcre *code, const pcre_extra *extra, PCRE_SPTR *subject, int *length, int *startoffset, int *options, int *ovector, int *ovecsize); + int (*postHookFunc) (int retVal___, const pcre *code, const pcre_extra *extra, PCRE_SPTR subject, int length, int startoffset, int options, int *ovector, int ovecsize); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_exec_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_exec_post[hIndex].func; - retVal___ = postHookFunc(retVal___, code, extra, &subject, &length, &startoffset, &options, ovector, &ovecsize); + retVal___ = postHookFunc(retVal___, code, extra, subject, length, startoffset, options, ovector, ovecsize); } } return retVal___; @@ -58164,11 +58387,11 @@ int HP_libpcre_exec(const pcre *code, const pcre_extra *extra, PCRE_SPTR subject void HP_libpcre_free(void *ptr) { int hIndex = 0; if( HPMHooks.count.HP_libpcre_free_pre ) { - void (*preHookFunc) (void *ptr); + void (*preHookFunc) (void **ptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_free_pre[hIndex].func; - preHookFunc(ptr); + preHookFunc(&ptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58191,11 +58414,11 @@ int HP_libpcre_copy_substring(const char *subject, int *ovector, int stringcount int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libpcre_copy_substring_pre ) { - int (*preHookFunc) (const char *subject, int *ovector, int *stringcount, int *stringnumber, char *buffer, int *buffersize); + int (*preHookFunc) (const char **subject, int **ovector, int *stringcount, int *stringnumber, char **buffer, int *buffersize); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_substring_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_copy_substring_pre[hIndex].func; - retVal___ = preHookFunc(subject, ovector, &stringcount, &stringnumber, buffer, &buffersize); + retVal___ = preHookFunc(&subject, &ovector, &stringcount, &stringnumber, &buffer, &buffersize); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58206,10 +58429,10 @@ int HP_libpcre_copy_substring(const char *subject, int *ovector, int stringcount retVal___ = HPMHooks.source.libpcre.copy_substring(subject, ovector, stringcount, stringnumber, buffer, buffersize); } if( HPMHooks.count.HP_libpcre_copy_substring_post ) { - int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int *stringcount, int *stringnumber, char *buffer, int *buffersize); + int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int buffersize); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_substring_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_copy_substring_post[hIndex].func; - retVal___ = postHookFunc(retVal___, subject, ovector, &stringcount, &stringnumber, buffer, &buffersize); + retVal___ = postHookFunc(retVal___, subject, ovector, stringcount, stringnumber, buffer, buffersize); } } return retVal___; @@ -58217,11 +58440,11 @@ int HP_libpcre_copy_substring(const char *subject, int *ovector, int stringcount void HP_libpcre_free_substring(const char *stringptr) { int hIndex = 0; if( HPMHooks.count.HP_libpcre_free_substring_pre ) { - void (*preHookFunc) (const char *stringptr); + void (*preHookFunc) (const char **stringptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_substring_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_free_substring_pre[hIndex].func; - preHookFunc(stringptr); + preHookFunc(&stringptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58244,11 +58467,11 @@ int HP_libpcre_copy_named_substring(const pcre *code, const char *subject, int * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libpcre_copy_named_substring_pre ) { - int (*preHookFunc) (const pcre *code, const char *subject, int *ovector, int *stringcount, const char *stringname, char *buffer, int *buffersize); + int (*preHookFunc) (const pcre **code, const char **subject, int **ovector, int *stringcount, const char **stringname, char **buffer, int *buffersize); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_named_substring_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_copy_named_substring_pre[hIndex].func; - retVal___ = preHookFunc(code, subject, ovector, &stringcount, stringname, buffer, &buffersize); + retVal___ = preHookFunc(&code, &subject, &ovector, &stringcount, &stringname, &buffer, &buffersize); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58259,10 +58482,10 @@ int HP_libpcre_copy_named_substring(const pcre *code, const char *subject, int * retVal___ = HPMHooks.source.libpcre.copy_named_substring(code, subject, ovector, stringcount, stringname, buffer, buffersize); } if( HPMHooks.count.HP_libpcre_copy_named_substring_post ) { - int (*postHookFunc) (int retVal___, const pcre *code, const char *subject, int *ovector, int *stringcount, const char *stringname, char *buffer, int *buffersize); + int (*postHookFunc) (int retVal___, const pcre *code, const char *subject, int *ovector, int stringcount, const char *stringname, char *buffer, int buffersize); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_named_substring_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_copy_named_substring_post[hIndex].func; - retVal___ = postHookFunc(retVal___, code, subject, ovector, &stringcount, stringname, buffer, &buffersize); + retVal___ = postHookFunc(retVal___, code, subject, ovector, stringcount, stringname, buffer, buffersize); } } return retVal___; @@ -58271,11 +58494,11 @@ int HP_libpcre_get_substring(const char *subject, int *ovector, int stringcount, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_libpcre_get_substring_pre ) { - int (*preHookFunc) (const char *subject, int *ovector, int *stringcount, int *stringnumber, const char **stringptr); + int (*preHookFunc) (const char **subject, int **ovector, int *stringcount, int *stringnumber, const char ***stringptr); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_get_substring_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_libpcre_get_substring_pre[hIndex].func; - retVal___ = preHookFunc(subject, ovector, &stringcount, &stringnumber, stringptr); + retVal___ = preHookFunc(&subject, &ovector, &stringcount, &stringnumber, &stringptr); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58286,10 +58509,10 @@ int HP_libpcre_get_substring(const char *subject, int *ovector, int stringcount, retVal___ = HPMHooks.source.libpcre.get_substring(subject, ovector, stringcount, stringnumber, stringptr); } if( HPMHooks.count.HP_libpcre_get_substring_post ) { - int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int *stringcount, int *stringnumber, const char **stringptr); + int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, const char **stringptr); for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_get_substring_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_libpcre_get_substring_post[hIndex].func; - retVal___ = postHookFunc(retVal___, subject, ovector, &stringcount, &stringnumber, stringptr); + retVal___ = postHookFunc(retVal___, subject, ovector, stringcount, stringnumber, stringptr); } } return retVal___; @@ -58314,10 +58537,10 @@ int HP_pet_init(bool minimal) { retVal___ = HPMHooks.source.pet.init(minimal); } if( HPMHooks.count.HP_pet_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -58353,11 +58576,11 @@ int HP_pet_hungry_val(struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_hungry_val_pre ) { - int (*preHookFunc) (struct pet_data *pd); + int (*preHookFunc) (struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_val_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_hungry_val_pre[hIndex].func; - retVal___ = preHookFunc(pd); + retVal___ = preHookFunc(&pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58379,11 +58602,11 @@ int HP_pet_hungry_val(struct pet_data *pd) { void HP_pet_set_intimate(struct pet_data *pd, int value) { int hIndex = 0; if( HPMHooks.count.HP_pet_set_intimate_pre ) { - void (*preHookFunc) (struct pet_data *pd, int *value); + void (*preHookFunc) (struct pet_data **pd, int *value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_set_intimate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_set_intimate_pre[hIndex].func; - preHookFunc(pd, &value); + preHookFunc(&pd, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58394,10 +58617,10 @@ void HP_pet_set_intimate(struct pet_data *pd, int value) { HPMHooks.source.pet.set_intimate(pd, value); } if( HPMHooks.count.HP_pet_set_intimate_post ) { - void (*postHookFunc) (struct pet_data *pd, int *value); + void (*postHookFunc) (struct pet_data *pd, int value); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_set_intimate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_set_intimate_post[hIndex].func; - postHookFunc(pd, &value); + postHookFunc(pd, value); } } return; @@ -58406,11 +58629,11 @@ int HP_pet_create_egg(struct map_session_data *sd, int item_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_create_egg_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *item_id); + int (*preHookFunc) (struct map_session_data **sd, int *item_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_create_egg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_create_egg_pre[hIndex].func; - retVal___ = preHookFunc(sd, &item_id); + retVal___ = preHookFunc(&sd, &item_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58421,10 +58644,10 @@ int HP_pet_create_egg(struct map_session_data *sd, int item_id) { retVal___ = HPMHooks.source.pet.create_egg(sd, item_id); } if( HPMHooks.count.HP_pet_create_egg_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *item_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int item_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_create_egg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_create_egg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &item_id); + retVal___ = postHookFunc(retVal___, sd, item_id); } } return retVal___; @@ -58433,11 +58656,11 @@ int HP_pet_unlocktarget(struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_unlocktarget_pre ) { - int (*preHookFunc) (struct pet_data *pd); + int (*preHookFunc) (struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unlocktarget_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_unlocktarget_pre[hIndex].func; - retVal___ = preHookFunc(pd); + retVal___ = preHookFunc(&pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58460,11 +58683,11 @@ int HP_pet_attackskill(struct pet_data *pd, int target_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_attackskill_pre ) { - int (*preHookFunc) (struct pet_data *pd, int *target_id); + int (*preHookFunc) (struct pet_data **pd, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_attackskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_attackskill_pre[hIndex].func; - retVal___ = preHookFunc(pd, &target_id); + retVal___ = preHookFunc(&pd, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58475,10 +58698,10 @@ int HP_pet_attackskill(struct pet_data *pd, int target_id) { retVal___ = HPMHooks.source.pet.attackskill(pd, target_id); } if( HPMHooks.count.HP_pet_attackskill_post ) { - int (*postHookFunc) (int retVal___, struct pet_data *pd, int *target_id); + int (*postHookFunc) (int retVal___, struct pet_data *pd, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_attackskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_attackskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pd, &target_id); + retVal___ = postHookFunc(retVal___, pd, target_id); } } return retVal___; @@ -58487,11 +58710,11 @@ int HP_pet_target_check(struct map_session_data *sd, struct block_list *bl, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_target_check_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, int *type); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_target_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_target_check_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl, &type); + retVal___ = preHookFunc(&sd, &bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58502,10 +58725,10 @@ int HP_pet_target_check(struct map_session_data *sd, struct block_list *bl, int retVal___ = HPMHooks.source.pet.target_check(sd, bl, type); } if( HPMHooks.count.HP_pet_target_check_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_target_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_target_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, bl, &type); + retVal___ = postHookFunc(retVal___, sd, bl, type); } } return retVal___; @@ -58514,11 +58737,11 @@ int HP_pet_sc_check(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_sc_check_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_sc_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_sc_check_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58529,10 +58752,10 @@ int HP_pet_sc_check(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.pet.sc_check(sd, type); } if( HPMHooks.count.HP_pet_sc_check_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_sc_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_sc_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -58556,10 +58779,10 @@ int HP_pet_hungry(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.hungry(tid, tick, id, data); } if( HPMHooks.count.HP_pet_hungry_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_hungry_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -58583,10 +58806,10 @@ int HP_pet_search_petDB_index(int key, int type) { retVal___ = HPMHooks.source.pet.search_petDB_index(key, type); } if( HPMHooks.count.HP_pet_search_petDB_index_post ) { - int (*postHookFunc) (int retVal___, int *key, int *type); + int (*postHookFunc) (int retVal___, int key, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_search_petDB_index_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_search_petDB_index_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, &type); + retVal___ = postHookFunc(retVal___, key, type); } } return retVal___; @@ -58595,11 +58818,11 @@ int HP_pet_hungry_timer_delete(struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_hungry_timer_delete_pre ) { - int (*preHookFunc) (struct pet_data *pd); + int (*preHookFunc) (struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_timer_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_hungry_timer_delete_pre[hIndex].func; - retVal___ = preHookFunc(pd); + retVal___ = preHookFunc(&pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58622,11 +58845,11 @@ int HP_pet_performance(struct map_session_data *sd, struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_performance_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd); + int (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_performance_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_performance_pre[hIndex].func; - retVal___ = preHookFunc(sd, pd); + retVal___ = preHookFunc(&sd, &pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58649,11 +58872,11 @@ int HP_pet_return_egg(struct map_session_data *sd, struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_return_egg_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd); + int (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_return_egg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_return_egg_pre[hIndex].func; - retVal___ = preHookFunc(sd, pd); + retVal___ = preHookFunc(&sd, &pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58676,11 +58899,11 @@ int HP_pet_data_init(struct map_session_data *sd, struct s_pet *petinfo) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_data_init_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo); + int (*preHookFunc) (struct map_session_data **sd, struct s_pet **petinfo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_data_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_data_init_pre[hIndex].func; - retVal___ = preHookFunc(sd, petinfo); + retVal___ = preHookFunc(&sd, &petinfo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58703,11 +58926,11 @@ int HP_pet_birth_process(struct map_session_data *sd, struct s_pet *petinfo) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_birth_process_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo); + int (*preHookFunc) (struct map_session_data **sd, struct s_pet **petinfo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_birth_process_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_birth_process_pre[hIndex].func; - retVal___ = preHookFunc(sd, petinfo); + retVal___ = preHookFunc(&sd, &petinfo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58730,11 +58953,11 @@ int HP_pet_recv_petdata(int account_id, struct s_pet *p, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_recv_petdata_pre ) { - int (*preHookFunc) (int *account_id, struct s_pet *p, int *flag); + int (*preHookFunc) (int *account_id, struct s_pet **p, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recv_petdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_recv_petdata_pre[hIndex].func; - retVal___ = preHookFunc(&account_id, p, &flag); + retVal___ = preHookFunc(&account_id, &p, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58745,10 +58968,10 @@ int HP_pet_recv_petdata(int account_id, struct s_pet *p, int flag) { retVal___ = HPMHooks.source.pet.recv_petdata(account_id, p, flag); } if( HPMHooks.count.HP_pet_recv_petdata_post ) { - int (*postHookFunc) (int retVal___, int *account_id, struct s_pet *p, int *flag); + int (*postHookFunc) (int retVal___, int account_id, struct s_pet *p, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recv_petdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_recv_petdata_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, p, &flag); + retVal___ = postHookFunc(retVal___, account_id, p, flag); } } return retVal___; @@ -58757,11 +58980,11 @@ int HP_pet_select_egg(struct map_session_data *sd, short egg_index) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_select_egg_pre ) { - int (*preHookFunc) (struct map_session_data *sd, short *egg_index); + int (*preHookFunc) (struct map_session_data **sd, short *egg_index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_select_egg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_select_egg_pre[hIndex].func; - retVal___ = preHookFunc(sd, &egg_index); + retVal___ = preHookFunc(&sd, &egg_index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58772,10 +58995,10 @@ int HP_pet_select_egg(struct map_session_data *sd, short egg_index) { retVal___ = HPMHooks.source.pet.select_egg(sd, egg_index); } if( HPMHooks.count.HP_pet_select_egg_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *egg_index); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, short egg_index); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_select_egg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_select_egg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &egg_index); + retVal___ = postHookFunc(retVal___, sd, egg_index); } } return retVal___; @@ -58784,11 +59007,11 @@ int HP_pet_catch_process1(struct map_session_data *sd, int target_class) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_catch_process1_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *target_class); + int (*preHookFunc) (struct map_session_data **sd, int *target_class); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process1_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_catch_process1_pre[hIndex].func; - retVal___ = preHookFunc(sd, &target_class); + retVal___ = preHookFunc(&sd, &target_class); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58799,10 +59022,10 @@ int HP_pet_catch_process1(struct map_session_data *sd, int target_class) { retVal___ = HPMHooks.source.pet.catch_process1(sd, target_class); } if( HPMHooks.count.HP_pet_catch_process1_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_class); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_class); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process1_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_catch_process1_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &target_class); + retVal___ = postHookFunc(retVal___, sd, target_class); } } return retVal___; @@ -58811,11 +59034,11 @@ int HP_pet_catch_process2(struct map_session_data *sd, int target_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_catch_process2_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *target_id); + int (*preHookFunc) (struct map_session_data **sd, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_catch_process2_pre[hIndex].func; - retVal___ = preHookFunc(sd, &target_id); + retVal___ = preHookFunc(&sd, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58826,10 +59049,10 @@ int HP_pet_catch_process2(struct map_session_data *sd, int target_id) { retVal___ = HPMHooks.source.pet.catch_process2(sd, target_id); } if( HPMHooks.count.HP_pet_catch_process2_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_catch_process2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &target_id); + retVal___ = postHookFunc(retVal___, sd, target_id); } } return retVal___; @@ -58853,10 +59076,10 @@ bool HP_pet_get_egg(int account_id, short pet_class, int pet_id) { retVal___ = HPMHooks.source.pet.get_egg(account_id, pet_class, pet_id); } if( HPMHooks.count.HP_pet_get_egg_post ) { - bool (*postHookFunc) (bool retVal___, int *account_id, short *pet_class, int *pet_id); + bool (*postHookFunc) (bool retVal___, int account_id, short pet_class, int pet_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_get_egg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_get_egg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &account_id, &pet_class, &pet_id); + retVal___ = postHookFunc(retVal___, account_id, pet_class, pet_id); } } return retVal___; @@ -58865,11 +59088,11 @@ int HP_pet_unequipitem(struct map_session_data *sd, struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_unequipitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd); + int (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unequipitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_unequipitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, pd); + retVal___ = preHookFunc(&sd, &pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58892,11 +59115,11 @@ int HP_pet_food(struct map_session_data *sd, struct pet_data *pd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_food_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd); + int (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_food_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_food_pre[hIndex].func; - retVal___ = preHookFunc(sd, pd); + retVal___ = preHookFunc(&sd, &pd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58919,12 +59142,12 @@ int HP_pet_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_lootsearch_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -58952,11 +59175,11 @@ int HP_pet_menu(struct map_session_data *sd, int menunum) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_menu_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *menunum); + int (*preHookFunc) (struct map_session_data **sd, int *menunum); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_menu_pre[hIndex].func; - retVal___ = preHookFunc(sd, &menunum); + retVal___ = preHookFunc(&sd, &menunum); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -58967,10 +59190,10 @@ int HP_pet_menu(struct map_session_data *sd, int menunum) { retVal___ = HPMHooks.source.pet.menu(sd, menunum); } if( HPMHooks.count.HP_pet_menu_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *menunum); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int menunum); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_menu_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &menunum); + retVal___ = postHookFunc(retVal___, sd, menunum); } } return retVal___; @@ -58979,11 +59202,11 @@ int HP_pet_change_name(struct map_session_data *sd, const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_change_name_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name); + int (*preHookFunc) (struct map_session_data **sd, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_change_name_pre[hIndex].func; - retVal___ = preHookFunc(sd, name); + retVal___ = preHookFunc(&sd, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59006,11 +59229,11 @@ int HP_pet_change_name_ack(struct map_session_data *sd, const char *name, int fl int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_change_name_ack_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const char *name, int *flag); + int (*preHookFunc) (struct map_session_data **sd, const char **name, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_change_name_ack_pre[hIndex].func; - retVal___ = preHookFunc(sd, name, &flag); + retVal___ = preHookFunc(&sd, &name, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59021,10 +59244,10 @@ int HP_pet_change_name_ack(struct map_session_data *sd, const char *name, int fl retVal___ = HPMHooks.source.pet.change_name_ack(sd, name, flag); } if( HPMHooks.count.HP_pet_change_name_ack_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int *flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_change_name_ack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, name, &flag); + retVal___ = postHookFunc(retVal___, sd, name, flag); } } return retVal___; @@ -59033,11 +59256,11 @@ int HP_pet_equipitem(struct map_session_data *sd, int index) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_equipitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index); + int (*preHookFunc) (struct map_session_data **sd, int *index); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_equipitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index); + retVal___ = preHookFunc(&sd, &index); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59048,10 +59271,10 @@ int HP_pet_equipitem(struct map_session_data *sd, int index) { retVal___ = HPMHooks.source.pet.equipitem(sd, index); } if( HPMHooks.count.HP_pet_equipitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_equipitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index); + retVal___ = postHookFunc(retVal___, sd, index); } } return retVal___; @@ -59060,11 +59283,11 @@ int HP_pet_randomwalk(struct pet_data *pd, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_randomwalk_pre ) { - int (*preHookFunc) (struct pet_data *pd, int64 *tick); + int (*preHookFunc) (struct pet_data **pd, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_randomwalk_pre[hIndex].func; - retVal___ = preHookFunc(pd, &tick); + retVal___ = preHookFunc(&pd, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59075,10 +59298,10 @@ int HP_pet_randomwalk(struct pet_data *pd, int64 tick) { retVal___ = HPMHooks.source.pet.randomwalk(pd, tick); } if( HPMHooks.count.HP_pet_randomwalk_post ) { - int (*postHookFunc) (int retVal___, struct pet_data *pd, int64 *tick); + int (*postHookFunc) (int retVal___, struct pet_data *pd, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_randomwalk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pd, &tick); + retVal___ = postHookFunc(retVal___, pd, tick); } } return retVal___; @@ -59087,11 +59310,11 @@ int HP_pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, int64 t int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_ai_sub_hard_pre ) { - int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd, int64 *tick); + int (*preHookFunc) (struct pet_data **pd, struct map_session_data **sd, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_pre[hIndex].func; - retVal___ = preHookFunc(pd, sd, &tick); + retVal___ = preHookFunc(&pd, &sd, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59102,10 +59325,10 @@ int HP_pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, int64 t retVal___ = HPMHooks.source.pet.ai_sub_hard(pd, sd, tick); } if( HPMHooks.count.HP_pet_ai_sub_hard_post ) { - int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd, int64 *tick); + int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pd, sd, &tick); + retVal___ = postHookFunc(retVal___, pd, sd, tick); } } return retVal___; @@ -59114,12 +59337,12 @@ int HP_pet_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_ai_sub_foreachclient_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_foreachclient_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_pet_ai_sub_foreachclient_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -59162,10 +59385,10 @@ int HP_pet_ai_hard(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.ai_hard(tid, tick, id, data); } if( HPMHooks.count.HP_pet_ai_hard_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_hard_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_ai_hard_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -59189,10 +59412,10 @@ int HP_pet_delay_item_drop(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.delay_item_drop(tid, tick, id, data); } if( HPMHooks.count.HP_pet_delay_item_drop_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_delay_item_drop_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_delay_item_drop_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -59201,11 +59424,11 @@ int HP_pet_lootitem_drop(struct pet_data *pd, struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_pet_lootitem_drop_pre ) { - int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd); + int (*preHookFunc) (struct pet_data **pd, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_lootitem_drop_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_pet_lootitem_drop_pre[hIndex].func; - retVal___ = preHookFunc(pd, sd); + retVal___ = preHookFunc(&pd, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59243,10 +59466,10 @@ int HP_pet_skill_bonus_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.skill_bonus_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pet_skill_bonus_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_bonus_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_skill_bonus_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -59270,10 +59493,10 @@ int HP_pet_recovery_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.recovery_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pet_recovery_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recovery_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_recovery_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -59297,10 +59520,10 @@ int HP_pet_skill_support_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.pet.skill_support_timer(tid, tick, id, data); } if( HPMHooks.count.HP_pet_skill_support_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_support_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_pet_skill_support_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -59351,10 +59574,10 @@ void HP_quest_init(bool minimal) { HPMHooks.source.quest.init(minimal); } if( HPMHooks.count.HP_quest_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -59430,10 +59653,10 @@ struct quest_db* HP_quest_db(int quest_id) { retVal___ = HPMHooks.source.quest.db(quest_id); } if( HPMHooks.count.HP_quest_db_post ) { - struct quest_db* (*postHookFunc) (struct quest_db* retVal___, int *quest_id); + struct quest_db* (*postHookFunc) (struct quest_db* retVal___, int quest_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_db_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_db_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &quest_id); + retVal___ = postHookFunc(retVal___, quest_id); } } return retVal___; @@ -59442,11 +59665,11 @@ int HP_quest_pc_login(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_pc_login_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_pc_login_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_pc_login_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59469,11 +59692,11 @@ int HP_quest_add(struct map_session_data *sd, int quest_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_add_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *quest_id); + int (*preHookFunc) (struct map_session_data **sd, int *quest_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_add_pre[hIndex].func; - retVal___ = preHookFunc(sd, &quest_id); + retVal___ = preHookFunc(&sd, &quest_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59484,10 +59707,10 @@ int HP_quest_add(struct map_session_data *sd, int quest_id) { retVal___ = HPMHooks.source.quest.add(sd, quest_id); } if( HPMHooks.count.HP_quest_add_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *quest_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &quest_id); + retVal___ = postHookFunc(retVal___, sd, quest_id); } } return retVal___; @@ -59496,11 +59719,11 @@ int HP_quest_change(struct map_session_data *sd, int qid1, int qid2) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_change_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *qid1, int *qid2); + int (*preHookFunc) (struct map_session_data **sd, int *qid1, int *qid2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_change_pre[hIndex].func; - retVal___ = preHookFunc(sd, &qid1, &qid2); + retVal___ = preHookFunc(&sd, &qid1, &qid2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59511,10 +59734,10 @@ int HP_quest_change(struct map_session_data *sd, int qid1, int qid2) { retVal___ = HPMHooks.source.quest.change(sd, qid1, qid2); } if( HPMHooks.count.HP_quest_change_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *qid1, int *qid2); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int qid1, int qid2); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_change_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &qid1, &qid2); + retVal___ = postHookFunc(retVal___, sd, qid1, qid2); } } return retVal___; @@ -59523,11 +59746,11 @@ int HP_quest_delete(struct map_session_data *sd, int quest_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_delete_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *quest_id); + int (*preHookFunc) (struct map_session_data **sd, int *quest_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_delete_pre[hIndex].func; - retVal___ = preHookFunc(sd, &quest_id); + retVal___ = preHookFunc(&sd, &quest_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59538,10 +59761,10 @@ int HP_quest_delete(struct map_session_data *sd, int quest_id) { retVal___ = HPMHooks.source.quest.delete(sd, quest_id); } if( HPMHooks.count.HP_quest_delete_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *quest_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &quest_id); + retVal___ = postHookFunc(retVal___, sd, quest_id); } } return retVal___; @@ -59550,12 +59773,12 @@ int HP_quest_update_objective_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_update_objective_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_quest_update_objective_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -59582,11 +59805,11 @@ int HP_quest_update_objective_sub(struct block_list *bl, va_list ap) { void HP_quest_update_objective(struct map_session_data *sd, int mob_id) { int hIndex = 0; if( HPMHooks.count.HP_quest_update_objective_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *mob_id); + void (*preHookFunc) (struct map_session_data **sd, int *mob_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_update_objective_pre[hIndex].func; - preHookFunc(sd, &mob_id); + preHookFunc(&sd, &mob_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59597,10 +59820,10 @@ void HP_quest_update_objective(struct map_session_data *sd, int mob_id) { HPMHooks.source.quest.update_objective(sd, mob_id); } if( HPMHooks.count.HP_quest_update_objective_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *mob_id); + void (*postHookFunc) (struct map_session_data *sd, int mob_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_update_objective_post[hIndex].func; - postHookFunc(sd, &mob_id); + postHookFunc(sd, mob_id); } } return; @@ -59609,11 +59832,11 @@ int HP_quest_update_status(struct map_session_data *sd, int quest_id, enum quest int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_update_status_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *quest_id, enum quest_state *qs); + int (*preHookFunc) (struct map_session_data **sd, int *quest_id, enum quest_state *qs); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_update_status_pre[hIndex].func; - retVal___ = preHookFunc(sd, &quest_id, &qs); + retVal___ = preHookFunc(&sd, &quest_id, &qs); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59624,10 +59847,10 @@ int HP_quest_update_status(struct map_session_data *sd, int quest_id, enum quest retVal___ = HPMHooks.source.quest.update_status(sd, quest_id, qs); } if( HPMHooks.count.HP_quest_update_status_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *quest_id, enum quest_state *qs); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_state qs); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_status_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_update_status_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &quest_id, &qs); + retVal___ = postHookFunc(retVal___, sd, quest_id, qs); } } return retVal___; @@ -59636,11 +59859,11 @@ int HP_quest_check(struct map_session_data *sd, int quest_id, enum quest_check_t int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_quest_check_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *quest_id, enum quest_check_type *type); + int (*preHookFunc) (struct map_session_data **sd, int *quest_id, enum quest_check_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_check_pre[hIndex].func; - retVal___ = preHookFunc(sd, &quest_id, &type); + retVal___ = preHookFunc(&sd, &quest_id, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59651,10 +59874,10 @@ int HP_quest_check(struct map_session_data *sd, int quest_id, enum quest_check_t retVal___ = HPMHooks.source.quest.check(sd, quest_id, type); } if( HPMHooks.count.HP_quest_check_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *quest_id, enum quest_check_type *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_check_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &quest_id, &type); + retVal___ = postHookFunc(retVal___, sd, quest_id, type); } } return retVal___; @@ -59716,11 +59939,11 @@ struct quest_db* HP_quest_read_db_sub(struct config_setting_t *cs, int n, const int hIndex = 0; struct quest_db* retVal___ = NULL; if( HPMHooks.count.HP_quest_read_db_sub_pre ) { - struct quest_db* (*preHookFunc) (struct config_setting_t *cs, int *n, const char *source); + struct quest_db* (*preHookFunc) (struct config_setting_t **cs, int *n, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_quest_read_db_sub_pre[hIndex].func; - retVal___ = preHookFunc(cs, &n, source); + retVal___ = preHookFunc(&cs, &n, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59731,10 +59954,10 @@ struct quest_db* HP_quest_read_db_sub(struct config_setting_t *cs, int n, const retVal___ = HPMHooks.source.quest.read_db_sub(cs, n, source); } if( HPMHooks.count.HP_quest_read_db_sub_post ) { - struct quest_db* (*postHookFunc) (struct quest_db* retVal___, struct config_setting_t *cs, int *n, const char *source); + struct quest_db* (*postHookFunc) (struct quest_db* retVal___, struct config_setting_t *cs, int n, const char *source); for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_quest_read_db_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, cs, &n, source); + retVal___ = postHookFunc(retVal___, cs, n, source); } } return retVal___; @@ -59758,10 +59981,10 @@ void HP_script_init(bool minimal) { HPMHooks.source.script.init(minimal); } if( HPMHooks.count.HP_script_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -59823,11 +60046,11 @@ struct script_code* HP_script_parse(const char *src, const char *file, int line, int hIndex = 0; struct script_code* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_pre ) { - struct script_code* (*preHookFunc) (const char *src, const char *file, int *line, int *options, int *retval); + struct script_code* (*preHookFunc) (const char **src, const char **file, int *line, int *options, int **retval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_pre[hIndex].func; - retVal___ = preHookFunc(src, file, &line, &options, retval); + retVal___ = preHookFunc(&src, &file, &line, &options, &retval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59838,10 +60061,10 @@ struct script_code* HP_script_parse(const char *src, const char *file, int line, retVal___ = HPMHooks.source.script.parse(src, file, line, options, retval); } if( HPMHooks.count.HP_script_parse_post ) { - struct script_code* (*postHookFunc) (struct script_code* retVal___, const char *src, const char *file, int *line, int *options, int *retval); + struct script_code* (*postHookFunc) (struct script_code* retVal___, const char *src, const char *file, int line, int options, int *retval); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, file, &line, &options, retval); + retVal___ = postHookFunc(retVal___, src, file, line, options, retval); } } return retVal___; @@ -59850,11 +60073,11 @@ bool HP_script_add_builtin(const struct script_function *buildin, bool override) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_script_add_builtin_pre ) { - bool (*preHookFunc) (const struct script_function *buildin, bool *override); + bool (*preHookFunc) (const struct script_function **buildin, bool *override); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_builtin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_builtin_pre[hIndex].func; - retVal___ = preHookFunc(buildin, &override); + retVal___ = preHookFunc(&buildin, &override); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59865,10 +60088,10 @@ bool HP_script_add_builtin(const struct script_function *buildin, bool override) retVal___ = HPMHooks.source.script.add_builtin(buildin, override); } if( HPMHooks.count.HP_script_add_builtin_post ) { - bool (*postHookFunc) (bool retVal___, const struct script_function *buildin, bool *override); + bool (*postHookFunc) (bool retVal___, const struct script_function *buildin, bool override); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_builtin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_add_builtin_post[hIndex].func; - retVal___ = postHookFunc(retVal___, buildin, &override); + retVal___ = postHookFunc(retVal___, buildin, override); } } return retVal___; @@ -59903,11 +60126,11 @@ const char* HP_script_parse_subexpr(const char *p, int limit) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_subexpr_pre ) { - const char* (*preHookFunc) (const char *p, int *limit); + const char* (*preHookFunc) (const char **p, int *limit); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_subexpr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_subexpr_pre[hIndex].func; - retVal___ = preHookFunc(p, &limit); + retVal___ = preHookFunc(&p, &limit); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59918,10 +60141,10 @@ const char* HP_script_parse_subexpr(const char *p, int limit) { retVal___ = HPMHooks.source.script.parse_subexpr(p, limit); } if( HPMHooks.count.HP_script_parse_subexpr_post ) { - const char* (*postHookFunc) (const char* retVal___, const char *p, int *limit); + const char* (*postHookFunc) (const char* retVal___, const char *p, int limit); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_subexpr_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_parse_subexpr_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &limit); + retVal___ = postHookFunc(retVal___, p, limit); } } return retVal___; @@ -59930,11 +60153,11 @@ const char* HP_script_skip_space(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_skip_space_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_space_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_skip_space_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59956,11 +60179,11 @@ const char* HP_script_skip_space(const char *p) { void HP_script_error(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) { int hIndex = 0; if( HPMHooks.count.HP_script_error_pre ) { - void (*preHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*preHookFunc) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_error_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_error_pre[hIndex].func; - preHookFunc(src, file, &start_line, error_msg, error_pos); + preHookFunc(&src, &file, &start_line, &error_msg, &error_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59971,10 +60194,10 @@ void HP_script_error(const char *src, const char *file, int start_line, const ch HPMHooks.source.script.error(src, file, start_line, error_msg, error_pos); } if( HPMHooks.count.HP_script_error_post ) { - void (*postHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*postHookFunc) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_error_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_error_post[hIndex].func; - postHookFunc(src, file, &start_line, error_msg, error_pos); + postHookFunc(src, file, start_line, error_msg, error_pos); } } return; @@ -59982,11 +60205,11 @@ void HP_script_error(const char *src, const char *file, int start_line, const ch void HP_script_warning(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) { int hIndex = 0; if( HPMHooks.count.HP_script_warning_pre ) { - void (*preHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*preHookFunc) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_warning_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_warning_pre[hIndex].func; - preHookFunc(src, file, &start_line, error_msg, error_pos); + preHookFunc(&src, &file, &start_line, &error_msg, &error_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -59997,10 +60220,10 @@ void HP_script_warning(const char *src, const char *file, int start_line, const HPMHooks.source.script.warning(src, file, start_line, error_msg, error_pos); } if( HPMHooks.count.HP_script_warning_post ) { - void (*postHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*postHookFunc) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_warning_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_warning_post[hIndex].func; - postHookFunc(src, file, &start_line, error_msg, error_pos); + postHookFunc(src, file, start_line, error_msg, error_pos); } } return; @@ -60009,11 +60232,11 @@ bool HP_script_addScript(char *name, char *args, bool ( *func ) (struct script_s int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_script_addScript_pre ) { - bool (*preHookFunc) (char *name, char *args, bool ( *func ) (struct script_state *st), bool *isDeprecated); + bool (*preHookFunc) (char **name, char **args, bool ( **func ) (struct script_state *st), bool *isDeprecated); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addScript_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_addScript_pre[hIndex].func; - retVal___ = preHookFunc(name, args, func, &isDeprecated); + retVal___ = preHookFunc(&name, &args, &func, &isDeprecated); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60024,10 +60247,10 @@ bool HP_script_addScript(char *name, char *args, bool ( *func ) (struct script_s retVal___ = HPMHooks.source.script.addScript(name, args, func, isDeprecated); } if( HPMHooks.count.HP_script_addScript_post ) { - bool (*postHookFunc) (bool retVal___, char *name, char *args, bool ( *func ) (struct script_state *st), bool *isDeprecated); + bool (*postHookFunc) (bool retVal___, char *name, char *args, bool ( *func ) (struct script_state *st), bool isDeprecated); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addScript_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_addScript_post[hIndex].func; - retVal___ = postHookFunc(retVal___, name, args, func, &isDeprecated); + retVal___ = postHookFunc(retVal___, name, args, func, isDeprecated); } } return retVal___; @@ -60036,11 +60259,11 @@ int HP_script_conv_num(struct script_state *st, struct script_data *data) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_conv_num_pre ) { - int (*preHookFunc) (struct script_state *st, struct script_data *data); + int (*preHookFunc) (struct script_state **st, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_conv_num_pre[hIndex].func; - retVal___ = preHookFunc(st, data); + retVal___ = preHookFunc(&st, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60063,11 +60286,11 @@ const char* HP_script_conv_str(struct script_state *st, struct script_data *data int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_conv_str_pre ) { - const char* (*preHookFunc) (struct script_state *st, struct script_data *data); + const char* (*preHookFunc) (struct script_state **st, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_conv_str_pre[hIndex].func; - retVal___ = preHookFunc(st, data); + retVal___ = preHookFunc(&st, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60090,11 +60313,11 @@ struct map_session_data* HP_script_rid2sd(struct script_state *st) { int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_script_rid2sd_pre ) { - struct map_session_data* (*preHookFunc) (struct script_state *st); + struct map_session_data* (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_rid2sd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_rid2sd_pre[hIndex].func; - retVal___ = preHookFunc(st); + retVal___ = preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60117,11 +60340,11 @@ struct map_session_data* HP_script_id2sd(struct script_state *st, int account_id int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_script_id2sd_pre ) { - struct map_session_data* (*preHookFunc) (struct script_state *st, int *account_id); + struct map_session_data* (*preHookFunc) (struct script_state **st, int *account_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_id2sd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_id2sd_pre[hIndex].func; - retVal___ = preHookFunc(st, &account_id); + retVal___ = preHookFunc(&st, &account_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60132,10 +60355,10 @@ struct map_session_data* HP_script_id2sd(struct script_state *st, int account_id retVal___ = HPMHooks.source.script.id2sd(st, account_id); } if( HPMHooks.count.HP_script_id2sd_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int *account_id); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_id2sd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_id2sd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, st, &account_id); + retVal___ = postHookFunc(retVal___, st, account_id); } } return retVal___; @@ -60144,11 +60367,11 @@ struct map_session_data* HP_script_charid2sd(struct script_state *st, int char_i int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_script_charid2sd_pre ) { - struct map_session_data* (*preHookFunc) (struct script_state *st, int *char_id); + struct map_session_data* (*preHookFunc) (struct script_state **st, int *char_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_charid2sd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_charid2sd_pre[hIndex].func; - retVal___ = preHookFunc(st, &char_id); + retVal___ = preHookFunc(&st, &char_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60159,10 +60382,10 @@ struct map_session_data* HP_script_charid2sd(struct script_state *st, int char_i retVal___ = HPMHooks.source.script.charid2sd(st, char_id); } if( HPMHooks.count.HP_script_charid2sd_post ) { - struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int *char_id); + struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int char_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_charid2sd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_charid2sd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, st, &char_id); + retVal___ = postHookFunc(retVal___, st, char_id); } } return retVal___; @@ -60171,11 +60394,11 @@ struct map_session_data* HP_script_nick2sd(struct script_state *st, const char * int hIndex = 0; struct map_session_data* retVal___ = NULL; if( HPMHooks.count.HP_script_nick2sd_pre ) { - struct map_session_data* (*preHookFunc) (struct script_state *st, const char *name); + struct map_session_data* (*preHookFunc) (struct script_state **st, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_nick2sd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_nick2sd_pre[hIndex].func; - retVal___ = preHookFunc(st, name); + retVal___ = preHookFunc(&st, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60197,11 +60420,11 @@ struct map_session_data* HP_script_nick2sd(struct script_state *st, const char * void HP_script_detach_rid(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_detach_rid_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_rid_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_detach_rid_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60224,11 +60447,11 @@ struct script_data* HP_script_push_val(struct script_stack *stack, enum c_op typ int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_push_val_pre ) { - struct script_data* (*preHookFunc) (struct script_stack *stack, enum c_op *type, int64 *val, struct reg_db *ref); + struct script_data* (*preHookFunc) (struct script_stack **stack, enum c_op *type, int64 *val, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_val_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_push_val_pre[hIndex].func; - retVal___ = preHookFunc(stack, &type, &val, ref); + retVal___ = preHookFunc(&stack, &type, &val, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60239,10 +60462,10 @@ struct script_data* HP_script_push_val(struct script_stack *stack, enum c_op typ retVal___ = HPMHooks.source.script.push_val(stack, type, val, ref); } if( HPMHooks.count.HP_script_push_val_post ) { - struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, enum c_op *type, int64 *val, struct reg_db *ref); + struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, enum c_op type, int64 val, struct reg_db *ref); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_val_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_push_val_post[hIndex].func; - retVal___ = postHookFunc(retVal___, stack, &type, &val, ref); + retVal___ = postHookFunc(retVal___, stack, type, val, ref); } } return retVal___; @@ -60251,11 +60474,11 @@ struct script_data* HP_script_get_val(struct script_state *st, struct script_dat int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val_pre ) { - struct script_data* (*preHookFunc) (struct script_state *st, struct script_data *data); + struct script_data* (*preHookFunc) (struct script_state **st, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_pre[hIndex].func; - retVal___ = preHookFunc(st, data); + retVal___ = preHookFunc(&st, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60278,11 +60501,11 @@ char* HP_script_get_val_ref_str(struct script_state *st, struct reg_db *n, struc int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val_ref_str_pre ) { - char* (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_ref_str_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60305,11 +60528,11 @@ char* HP_script_get_val_scope_str(struct script_state *st, struct reg_db *n, str int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val_scope_str_pre ) { - char* (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_scope_str_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60332,11 +60555,11 @@ char* HP_script_get_val_npc_str(struct script_state *st, struct reg_db *n, struc int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val_npc_str_pre ) { - char* (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_npc_str_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60359,11 +60582,11 @@ char* HP_script_get_val_instance_str(struct script_state *st, const char *name, int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val_instance_str_pre ) { - char* (*preHookFunc) (struct script_state *st, const char *name, struct script_data *data); + char* (*preHookFunc) (struct script_state **st, const char **name, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_instance_str_pre[hIndex].func; - retVal___ = preHookFunc(st, name, data); + retVal___ = preHookFunc(&st, &name, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60386,11 +60609,11 @@ int HP_script_get_val_ref_num(struct script_state *st, struct reg_db *n, struct int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_get_val_ref_num_pre ) { - int (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_ref_num_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60413,11 +60636,11 @@ int HP_script_get_val_scope_num(struct script_state *st, struct reg_db *n, struc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_get_val_scope_num_pre ) { - int (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_scope_num_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60440,11 +60663,11 @@ int HP_script_get_val_npc_num(struct script_state *st, struct reg_db *n, struct int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_get_val_npc_num_pre ) { - int (*preHookFunc) (struct script_state *st, struct reg_db *n, struct script_data *data); + int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_npc_num_pre[hIndex].func; - retVal___ = preHookFunc(st, n, data); + retVal___ = preHookFunc(&st, &n, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60467,11 +60690,11 @@ int HP_script_get_val_instance_num(struct script_state *st, const char *name, st int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_get_val_instance_num_pre ) { - int (*preHookFunc) (struct script_state *st, const char *name, struct script_data *data); + int (*preHookFunc) (struct script_state **st, const char **name, struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val_instance_num_pre[hIndex].func; - retVal___ = preHookFunc(st, name, data); + retVal___ = preHookFunc(&st, &name, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60494,11 +60717,11 @@ const void* HP_script_get_val2(struct script_state *st, int64 uid, struct reg_db int hIndex = 0; const void* retVal___ = NULL; if( HPMHooks.count.HP_script_get_val2_pre ) { - const void* (*preHookFunc) (struct script_state *st, int64 *uid, struct reg_db *ref); + const void* (*preHookFunc) (struct script_state **st, int64 *uid, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_val2_pre[hIndex].func; - retVal___ = preHookFunc(st, &uid, ref); + retVal___ = preHookFunc(&st, &uid, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60509,10 +60732,10 @@ const void* HP_script_get_val2(struct script_state *st, int64 uid, struct reg_db retVal___ = HPMHooks.source.script.get_val2(st, uid, ref); } if( HPMHooks.count.HP_script_get_val2_post ) { - const void* (*postHookFunc) (const void* retVal___, struct script_state *st, int64 *uid, struct reg_db *ref); + const void* (*postHookFunc) (const void* retVal___, struct script_state *st, int64 uid, struct reg_db *ref); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_get_val2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, st, &uid, ref); + retVal___ = postHookFunc(retVal___, st, uid, ref); } } return retVal___; @@ -60521,11 +60744,11 @@ struct script_data* HP_script_push_str(struct script_stack *stack, char *str) { int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_push_str_pre ) { - struct script_data* (*preHookFunc) (struct script_stack *stack, char *str); + struct script_data* (*preHookFunc) (struct script_stack **stack, char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_push_str_pre[hIndex].func; - retVal___ = preHookFunc(stack, str); + retVal___ = preHookFunc(&stack, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60548,11 +60771,11 @@ struct script_data* HP_script_push_conststr(struct script_stack *stack, const ch int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_push_conststr_pre ) { - struct script_data* (*preHookFunc) (struct script_stack *stack, const char *str); + struct script_data* (*preHookFunc) (struct script_stack **stack, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_conststr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_push_conststr_pre[hIndex].func; - retVal___ = preHookFunc(stack, str); + retVal___ = preHookFunc(&stack, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60575,11 +60798,11 @@ struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) { int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_push_copy_pre ) { - struct script_data* (*preHookFunc) (struct script_stack *stack, int *pos); + struct script_data* (*preHookFunc) (struct script_stack **stack, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_copy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_push_copy_pre[hIndex].func; - retVal___ = preHookFunc(stack, &pos); + retVal___ = preHookFunc(&stack, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60590,10 +60813,10 @@ struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) { retVal___ = HPMHooks.source.script.push_copy(stack, pos); } if( HPMHooks.count.HP_script_push_copy_post ) { - struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, int *pos); + struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_copy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_push_copy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, stack, &pos); + retVal___ = postHookFunc(retVal___, stack, pos); } } return retVal___; @@ -60601,11 +60824,11 @@ struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) { void HP_script_pop_stack(struct script_state *st, int start, int end) { int hIndex = 0; if( HPMHooks.count.HP_script_pop_stack_pre ) { - void (*preHookFunc) (struct script_state *st, int *start, int *end); + void (*preHookFunc) (struct script_state **st, int *start, int *end); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_stack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_pop_stack_pre[hIndex].func; - preHookFunc(st, &start, &end); + preHookFunc(&st, &start, &end); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60616,10 +60839,10 @@ void HP_script_pop_stack(struct script_state *st, int start, int end) { HPMHooks.source.script.pop_stack(st, start, end); } if( HPMHooks.count.HP_script_pop_stack_post ) { - void (*postHookFunc) (struct script_state *st, int *start, int *end); + void (*postHookFunc) (struct script_state *st, int start, int end); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_stack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_pop_stack_post[hIndex].func; - postHookFunc(st, &start, &end); + postHookFunc(st, start, end); } } return; @@ -60627,11 +60850,11 @@ void HP_script_pop_stack(struct script_state *st, int start, int end) { void HP_script_set_constant(const char *name, int value, bool is_parameter, bool is_deprecated) { int hIndex = 0; if( HPMHooks.count.HP_script_set_constant_pre ) { - void (*preHookFunc) (const char *name, int *value, bool *is_parameter, bool *is_deprecated); + void (*preHookFunc) (const char **name, int *value, bool *is_parameter, bool *is_deprecated); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_constant_pre[hIndex].func; - preHookFunc(name, &value, &is_parameter, &is_deprecated); + preHookFunc(&name, &value, &is_parameter, &is_deprecated); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60642,10 +60865,10 @@ void HP_script_set_constant(const char *name, int value, bool is_parameter, bool HPMHooks.source.script.set_constant(name, value, is_parameter, is_deprecated); } if( HPMHooks.count.HP_script_set_constant_post ) { - void (*postHookFunc) (const char *name, int *value, bool *is_parameter, bool *is_deprecated); + void (*postHookFunc) (const char *name, int value, bool is_parameter, bool is_deprecated); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_constant_post[hIndex].func; - postHookFunc(name, &value, &is_parameter, &is_deprecated); + postHookFunc(name, value, is_parameter, is_deprecated); } } return; @@ -60653,11 +60876,11 @@ void HP_script_set_constant(const char *name, int value, bool is_parameter, bool void HP_script_set_constant2(const char *name, int value, bool is_parameter, bool is_deprecated) { int hIndex = 0; if( HPMHooks.count.HP_script_set_constant2_pre ) { - void (*preHookFunc) (const char *name, int *value, bool *is_parameter, bool *is_deprecated); + void (*preHookFunc) (const char **name, int *value, bool *is_parameter, bool *is_deprecated); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_constant2_pre[hIndex].func; - preHookFunc(name, &value, &is_parameter, &is_deprecated); + preHookFunc(&name, &value, &is_parameter, &is_deprecated); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60668,10 +60891,10 @@ void HP_script_set_constant2(const char *name, int value, bool is_parameter, boo HPMHooks.source.script.set_constant2(name, value, is_parameter, is_deprecated); } if( HPMHooks.count.HP_script_set_constant2_post ) { - void (*postHookFunc) (const char *name, int *value, bool *is_parameter, bool *is_deprecated); + void (*postHookFunc) (const char *name, int value, bool is_parameter, bool is_deprecated); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_constant2_post[hIndex].func; - postHookFunc(name, &value, &is_parameter, &is_deprecated); + postHookFunc(name, value, is_parameter, is_deprecated); } } return; @@ -60680,11 +60903,11 @@ bool HP_script_get_constant(const char *name, int *value) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_script_get_constant_pre ) { - bool (*preHookFunc) (const char *name, int *value); + bool (*preHookFunc) (const char **name, int **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_constant_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_constant_pre[hIndex].func; - retVal___ = preHookFunc(name, value); + retVal___ = preHookFunc(&name, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60721,10 +60944,10 @@ void HP_script_label_add(int key, int pos) { HPMHooks.source.script.label_add(key, pos); } if( HPMHooks.count.HP_script_label_add_post ) { - void (*postHookFunc) (int *key, int *pos); + void (*postHookFunc) (int key, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_label_add_post[hIndex].func; - postHookFunc(&key, &pos); + postHookFunc(key, pos); } } return; @@ -60732,11 +60955,11 @@ void HP_script_label_add(int key, int pos) { void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_pre ) { - void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_pre[hIndex].func; - preHookFunc(rootscript, &pos, &rid, &oid); + preHookFunc(&rootscript, &pos, &rid, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60747,10 +60970,10 @@ void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) { HPMHooks.source.script.run(rootscript, pos, rid, oid); } if( HPMHooks.count.HP_script_run_post ) { - void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_post[hIndex].func; - postHookFunc(rootscript, &pos, &rid, &oid); + postHookFunc(rootscript, pos, rid, oid); } } return; @@ -60758,11 +60981,11 @@ void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) { void HP_script_run_npc(struct script_code *rootscript, int pos, int rid, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_npc_pre ) { - void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_npc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_npc_pre[hIndex].func; - preHookFunc(rootscript, &pos, &rid, &oid); + preHookFunc(&rootscript, &pos, &rid, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60773,10 +60996,10 @@ void HP_script_run_npc(struct script_code *rootscript, int pos, int rid, int oid HPMHooks.source.script.run_npc(rootscript, pos, rid, oid); } if( HPMHooks.count.HP_script_run_npc_post ) { - void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_npc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_npc_post[hIndex].func; - postHookFunc(rootscript, &pos, &rid, &oid); + postHookFunc(rootscript, pos, rid, oid); } } return; @@ -60784,11 +61007,11 @@ void HP_script_run_npc(struct script_code *rootscript, int pos, int rid, int oid void HP_script_run_pet(struct script_code *rootscript, int pos, int rid, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_pet_pre ) { - void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pet_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_pet_pre[hIndex].func; - preHookFunc(rootscript, &pos, &rid, &oid); + preHookFunc(&rootscript, &pos, &rid, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60799,10 +61022,10 @@ void HP_script_run_pet(struct script_code *rootscript, int pos, int rid, int oid HPMHooks.source.script.run_pet(rootscript, pos, rid, oid); } if( HPMHooks.count.HP_script_run_pet_post ) { - void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pet_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_pet_post[hIndex].func; - postHookFunc(rootscript, &pos, &rid, &oid); + postHookFunc(rootscript, pos, rid, oid); } } return; @@ -60810,11 +61033,11 @@ void HP_script_run_pet(struct script_code *rootscript, int pos, int rid, int oid void HP_script_run_main(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_run_main_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_main_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_main_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60852,10 +61075,10 @@ int HP_script_run_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.script.run_timer(tid, tick, id, data); } if( HPMHooks.count.HP_script_run_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -60864,11 +61087,11 @@ int HP_script_set_var(struct map_session_data *sd, char *name, void *val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_set_var_pre ) { - int (*preHookFunc) (struct map_session_data *sd, char *name, void *val); + int (*preHookFunc) (struct map_session_data **sd, char **name, void **val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_var_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_var_pre[hIndex].func; - retVal___ = preHookFunc(sd, name, val); + retVal___ = preHookFunc(&sd, &name, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60890,11 +61113,11 @@ int HP_script_set_var(struct map_session_data *sd, char *name, void *val) { void HP_script_stop_instances(struct script_code *code) { int hIndex = 0; if( HPMHooks.count.HP_script_stop_instances_pre ) { - void (*preHookFunc) (struct script_code *code); + void (*preHookFunc) (struct script_code **code); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stop_instances_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_stop_instances_pre[hIndex].func; - preHookFunc(code); + preHookFunc(&code); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60916,11 +61139,11 @@ void HP_script_stop_instances(struct script_code *code) { void HP_script_free_code(struct script_code *code) { int hIndex = 0; if( HPMHooks.count.HP_script_free_code_pre ) { - void (*preHookFunc) (struct script_code *code); + void (*preHookFunc) (struct script_code **code); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_code_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_free_code_pre[hIndex].func; - preHookFunc(code); + preHookFunc(&code); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60942,11 +61165,11 @@ void HP_script_free_code(struct script_code *code) { void HP_script_free_vars(struct DBMap *var_storage) { int hIndex = 0; if( HPMHooks.count.HP_script_free_vars_pre ) { - void (*preHookFunc) (struct DBMap *var_storage); + void (*preHookFunc) (struct DBMap **var_storage); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_vars_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_free_vars_pre[hIndex].func; - preHookFunc(var_storage); + preHookFunc(&var_storage); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60969,11 +61192,11 @@ struct script_state* HP_script_alloc_state(struct script_code *rootscript, int p int hIndex = 0; struct script_state* retVal___ = NULL; if( HPMHooks.count.HP_script_alloc_state_pre ) { - struct script_state* (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid); + struct script_state* (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_alloc_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_alloc_state_pre[hIndex].func; - retVal___ = preHookFunc(rootscript, &pos, &rid, &oid); + retVal___ = preHookFunc(&rootscript, &pos, &rid, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -60984,10 +61207,10 @@ struct script_state* HP_script_alloc_state(struct script_code *rootscript, int p retVal___ = HPMHooks.source.script.alloc_state(rootscript, pos, rid, oid); } if( HPMHooks.count.HP_script_alloc_state_post ) { - struct script_state* (*postHookFunc) (struct script_state* retVal___, struct script_code *rootscript, int *pos, int *rid, int *oid); + struct script_state* (*postHookFunc) (struct script_state* retVal___, struct script_code *rootscript, int pos, int rid, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_alloc_state_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_alloc_state_post[hIndex].func; - retVal___ = postHookFunc(retVal___, rootscript, &pos, &rid, &oid); + retVal___ = postHookFunc(retVal___, rootscript, pos, rid, oid); } } return retVal___; @@ -60995,11 +61218,11 @@ struct script_state* HP_script_alloc_state(struct script_code *rootscript, int p void HP_script_free_state(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_free_state_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_free_state_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61021,11 +61244,11 @@ void HP_script_free_state(struct script_state *st) { void HP_script_add_pending_ref(struct script_state *st, struct reg_db *ref) { int hIndex = 0; if( HPMHooks.count.HP_script_add_pending_ref_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *ref); + void (*preHookFunc) (struct script_state **st, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_pending_ref_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_pending_ref_pre[hIndex].func; - preHookFunc(st, ref); + preHookFunc(&st, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61047,11 +61270,11 @@ void HP_script_add_pending_ref(struct script_state *st, struct reg_db *ref) { void HP_script_run_autobonus(const char *autobonus, int id, int pos) { int hIndex = 0; if( HPMHooks.count.HP_script_run_autobonus_pre ) { - void (*preHookFunc) (const char *autobonus, int *id, int *pos); + void (*preHookFunc) (const char **autobonus, int *id, int *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_autobonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_autobonus_pre[hIndex].func; - preHookFunc(autobonus, &id, &pos); + preHookFunc(&autobonus, &id, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61062,10 +61285,10 @@ void HP_script_run_autobonus(const char *autobonus, int id, int pos) { HPMHooks.source.script.run_autobonus(autobonus, id, pos); } if( HPMHooks.count.HP_script_run_autobonus_post ) { - void (*postHookFunc) (const char *autobonus, int *id, int *pos); + void (*postHookFunc) (const char *autobonus, int id, int pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_autobonus_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_autobonus_post[hIndex].func; - postHookFunc(autobonus, &id, &pos); + postHookFunc(autobonus, id, pos); } } return; @@ -61073,11 +61296,11 @@ void HP_script_run_autobonus(const char *autobonus, int id, int pos) { void HP_script_cleararray_pc(struct map_session_data *sd, const char *varname, void *value) { int hIndex = 0; if( HPMHooks.count.HP_script_cleararray_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *varname, void *value); + void (*preHookFunc) (struct map_session_data **sd, const char **varname, void **value); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleararray_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_cleararray_pc_pre[hIndex].func; - preHookFunc(sd, varname, value); + preHookFunc(&sd, &varname, &value); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61099,11 +61322,11 @@ void HP_script_cleararray_pc(struct map_session_data *sd, const char *varname, v void HP_script_setarray_pc(struct map_session_data *sd, const char *varname, uint32 idx, void *value, int *refcache) { int hIndex = 0; if( HPMHooks.count.HP_script_setarray_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *varname, uint32 *idx, void *value, int *refcache); + void (*preHookFunc) (struct map_session_data **sd, const char **varname, uint32 *idx, void **value, int **refcache); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setarray_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_setarray_pc_pre[hIndex].func; - preHookFunc(sd, varname, &idx, value, refcache); + preHookFunc(&sd, &varname, &idx, &value, &refcache); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61114,10 +61337,10 @@ void HP_script_setarray_pc(struct map_session_data *sd, const char *varname, uin HPMHooks.source.script.setarray_pc(sd, varname, idx, value, refcache); } if( HPMHooks.count.HP_script_setarray_pc_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *varname, uint32 *idx, void *value, int *refcache); + void (*postHookFunc) (struct map_session_data *sd, const char *varname, uint32 idx, void *value, int *refcache); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setarray_pc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_setarray_pc_post[hIndex].func; - postHookFunc(sd, varname, &idx, value, refcache); + postHookFunc(sd, varname, idx, value, refcache); } } return; @@ -61126,11 +61349,11 @@ int HP_script_config_read(char *cfgName) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_config_read_pre ) { - int (*preHookFunc) (char *cfgName); + int (*preHookFunc) (char **cfgName); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_config_read_pre[hIndex].func; - retVal___ = preHookFunc(cfgName); + retVal___ = preHookFunc(&cfgName); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61153,11 +61376,11 @@ int HP_script_add_str(const char *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_add_str_pre ) { - int (*preHookFunc) (const char *p); + int (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_str_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61195,10 +61418,10 @@ const char* HP_script_get_str(int id) { retVal___ = HPMHooks.source.script.get_str(id); } if( HPMHooks.count.HP_script_get_str_post ) { - const char* (*postHookFunc) (const char* retVal___, int *id); + const char* (*postHookFunc) (const char* retVal___, int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_get_str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &id); + retVal___ = postHookFunc(retVal___, id); } } return retVal___; @@ -61207,11 +61430,11 @@ int HP_script_search_str(const char *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_search_str_pre ) { - int (*preHookFunc) (const char *p); + int (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_search_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_search_str_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61233,11 +61456,11 @@ int HP_script_search_str(const char *p) { void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, const char *varname, int elem, const void *value, struct reg_db *ref) { int hIndex = 0; if( HPMHooks.count.HP_script_setd_sub_pre ) { - void (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int *elem, const void *value, struct reg_db *ref); + void (*preHookFunc) (struct script_state **st, struct map_session_data **sd, const char **varname, int *elem, const void **value, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setd_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_setd_sub_pre[hIndex].func; - preHookFunc(st, sd, varname, &elem, value, ref); + preHookFunc(&st, &sd, &varname, &elem, &value, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61248,10 +61471,10 @@ void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, co HPMHooks.source.script.setd_sub(st, sd, varname, elem, value, ref); } if( HPMHooks.count.HP_script_setd_sub_post ) { - void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int *elem, const void *value, struct reg_db *ref); + void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int elem, const void *value, struct reg_db *ref); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setd_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_setd_sub_post[hIndex].func; - postHookFunc(st, sd, varname, &elem, value, ref); + postHookFunc(st, sd, varname, elem, value, ref); } } return; @@ -61259,11 +61482,11 @@ void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, co void HP_script_attach_state(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_attach_state_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_attach_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_attach_state_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61301,10 +61524,10 @@ struct script_queue* HP_script_queue(int idx) { retVal___ = HPMHooks.source.script.queue(idx); } if( HPMHooks.count.HP_script_queue_post ) { - struct script_queue* (*postHookFunc) (struct script_queue* retVal___, int *idx); + struct script_queue* (*postHookFunc) (struct script_queue* retVal___, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_queue_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx); + retVal___ = postHookFunc(retVal___, idx); } } return retVal___; @@ -61328,10 +61551,10 @@ bool HP_script_queue_add(int idx, int var) { retVal___ = HPMHooks.source.script.queue_add(idx, var); } if( HPMHooks.count.HP_script_queue_add_post ) { - bool (*postHookFunc) (bool retVal___, int *idx, int *var); + bool (*postHookFunc) (bool retVal___, int idx, int var); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_queue_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx, &var); + retVal___ = postHookFunc(retVal___, idx, var); } } return retVal___; @@ -61355,10 +61578,10 @@ bool HP_script_queue_del(int idx) { retVal___ = HPMHooks.source.script.queue_del(idx); } if( HPMHooks.count.HP_script_queue_del_post ) { - bool (*postHookFunc) (bool retVal___, int *idx); + bool (*postHookFunc) (bool retVal___, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_del_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_queue_del_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx); + retVal___ = postHookFunc(retVal___, idx); } } return retVal___; @@ -61382,10 +61605,10 @@ bool HP_script_queue_remove(int idx, int var) { retVal___ = HPMHooks.source.script.queue_remove(idx, var); } if( HPMHooks.count.HP_script_queue_remove_post ) { - bool (*postHookFunc) (bool retVal___, int *idx, int *var); + bool (*postHookFunc) (bool retVal___, int idx, int var); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_remove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_queue_remove_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx, &var); + retVal___ = postHookFunc(retVal___, idx, var); } } return retVal___; @@ -61436,10 +61659,10 @@ bool HP_script_queue_clear(int idx) { retVal___ = HPMHooks.source.script.queue_clear(idx); } if( HPMHooks.count.HP_script_queue_clear_post ) { - bool (*postHookFunc) (bool retVal___, int *idx); + bool (*postHookFunc) (bool retVal___, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_clear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_queue_clear_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx); + retVal___ = postHookFunc(retVal___, idx); } } return retVal___; @@ -61448,11 +61671,11 @@ const char* HP_script_parse_curly_close(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_curly_close_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_curly_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_curly_close_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61475,11 +61698,11 @@ const char* HP_script_parse_syntax_close(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_syntax_close_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_syntax_close_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61502,11 +61725,11 @@ const char* HP_script_parse_syntax_close_sub(const char *p, int *flag) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_syntax_close_sub_pre ) { - const char* (*preHookFunc) (const char *p, int *flag); + const char* (*preHookFunc) (const char **p, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_syntax_close_sub_pre[hIndex].func; - retVal___ = preHookFunc(p, flag); + retVal___ = preHookFunc(&p, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61529,11 +61752,11 @@ const char* HP_script_parse_syntax(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_syntax_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_syntax_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61552,15 +61775,15 @@ const char* HP_script_parse_syntax(const char *p) { } return retVal___; } -c_op HP_script_get_com(unsigned char *scriptbuf, int *pos) { +c_op HP_script_get_com(const struct script_buf *scriptbuf, int *pos) { int hIndex = 0; c_op retVal___ = C_NOP; if( HPMHooks.count.HP_script_get_com_pre ) { - c_op (*preHookFunc) (unsigned char *scriptbuf, int *pos); + c_op (*preHookFunc) (const struct script_buf **scriptbuf, int **pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_com_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_com_pre[hIndex].func; - retVal___ = preHookFunc(scriptbuf, pos); + retVal___ = preHookFunc(&scriptbuf, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61571,7 +61794,7 @@ c_op HP_script_get_com(unsigned char *scriptbuf, int *pos) { retVal___ = HPMHooks.source.script.get_com(scriptbuf, pos); } if( HPMHooks.count.HP_script_get_com_post ) { - c_op (*postHookFunc) (c_op retVal___, unsigned char *scriptbuf, int *pos); + c_op (*postHookFunc) (c_op retVal___, const struct script_buf *scriptbuf, int *pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_com_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_get_com_post[hIndex].func; retVal___ = postHookFunc(retVal___, scriptbuf, pos); @@ -61579,15 +61802,15 @@ c_op HP_script_get_com(unsigned char *scriptbuf, int *pos) { } return retVal___; } -int HP_script_get_num(unsigned char *scriptbuf, int *pos) { +int HP_script_get_num(const struct script_buf *scriptbuf, int *pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_get_num_pre ) { - int (*preHookFunc) (unsigned char *scriptbuf, int *pos); + int (*preHookFunc) (const struct script_buf **scriptbuf, int **pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_num_pre[hIndex].func; - retVal___ = preHookFunc(scriptbuf, pos); + retVal___ = preHookFunc(&scriptbuf, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61598,7 +61821,7 @@ int HP_script_get_num(unsigned char *scriptbuf, int *pos) { retVal___ = HPMHooks.source.script.get_num(scriptbuf, pos); } if( HPMHooks.count.HP_script_get_num_post ) { - int (*postHookFunc) (int retVal___, unsigned char *scriptbuf, int *pos); + int (*postHookFunc) (int retVal___, const struct script_buf *scriptbuf, int *pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_get_num_post[hIndex].func; retVal___ = postHookFunc(retVal___, scriptbuf, pos); @@ -61625,10 +61848,10 @@ const char* HP_script_op2name(int op) { retVal___ = HPMHooks.source.script.op2name(op); } if( HPMHooks.count.HP_script_op2name_post ) { - const char* (*postHookFunc) (const char* retVal___, int *op); + const char* (*postHookFunc) (const char* retVal___, int op); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op2name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op2name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &op); + retVal___ = postHookFunc(retVal___, op); } } return retVal___; @@ -61636,11 +61859,11 @@ const char* HP_script_op2name(int op) { void HP_script_reportsrc(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_reportsrc_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportsrc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_reportsrc_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61662,11 +61885,11 @@ void HP_script_reportsrc(struct script_state *st) { void HP_script_reportdata(struct script_data *data) { int hIndex = 0; if( HPMHooks.count.HP_script_reportdata_pre ) { - void (*preHookFunc) (struct script_data *data); + void (*preHookFunc) (struct script_data **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_reportdata_pre[hIndex].func; - preHookFunc(data); + preHookFunc(&data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61688,11 +61911,11 @@ void HP_script_reportdata(struct script_data *data) { void HP_script_reportfunc(struct script_state *st) { int hIndex = 0; if( HPMHooks.count.HP_script_reportfunc_pre ) { - void (*preHookFunc) (struct script_state *st); + void (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportfunc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_reportfunc_pre[hIndex].func; - preHookFunc(st); + preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61714,11 +61937,11 @@ void HP_script_reportfunc(struct script_state *st) { void HP_script_disp_warning_message(const char *mes, const char *pos) { int hIndex = 0; if( HPMHooks.count.HP_script_disp_warning_message_pre ) { - void (*preHookFunc) (const char *mes, const char *pos); + void (*preHookFunc) (const char **mes, const char **pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_warning_message_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_disp_warning_message_pre[hIndex].func; - preHookFunc(mes, pos); + preHookFunc(&mes, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61740,11 +61963,11 @@ void HP_script_disp_warning_message(const char *mes, const char *pos) { void HP_script_check_event(struct script_state *st, const char *evt) { int hIndex = 0; if( HPMHooks.count.HP_script_check_event_pre ) { - void (*preHookFunc) (struct script_state *st, const char *evt); + void (*preHookFunc) (struct script_state **st, const char **evt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_event_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_check_event_pre[hIndex].func; - preHookFunc(st, evt); + preHookFunc(&st, &evt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61767,11 +61990,11 @@ unsigned int HP_script_calc_hash(const char *p) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_script_calc_hash_pre ) { - unsigned int (*preHookFunc) (const char *p); + unsigned int (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_calc_hash_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61808,10 +62031,10 @@ void HP_script_addb(int a) { HPMHooks.source.script.addb(a); } if( HPMHooks.count.HP_script_addb_post ) { - void (*postHookFunc) (int *a); + void (*postHookFunc) (int a); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_addb_post[hIndex].func; - postHookFunc(&a); + postHookFunc(a); } } return; @@ -61834,10 +62057,10 @@ void HP_script_addc(int a) { HPMHooks.source.script.addc(a); } if( HPMHooks.count.HP_script_addc_post ) { - void (*postHookFunc) (int *a); + void (*postHookFunc) (int a); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_addc_post[hIndex].func; - postHookFunc(&a); + postHookFunc(a); } } return; @@ -61860,10 +62083,10 @@ void HP_script_addi(int a) { HPMHooks.source.script.addi(a); } if( HPMHooks.count.HP_script_addi_post ) { - void (*postHookFunc) (int *a); + void (*postHookFunc) (int a); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addi_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_addi_post[hIndex].func; - postHookFunc(&a); + postHookFunc(a); } } return; @@ -61886,10 +62109,10 @@ void HP_script_addl(int l) { HPMHooks.source.script.addl(l); } if( HPMHooks.count.HP_script_addl_post ) { - void (*postHookFunc) (int *l); + void (*postHookFunc) (int l); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_addl_post[hIndex].func; - postHookFunc(&l); + postHookFunc(l); } } return; @@ -61897,11 +62120,11 @@ void HP_script_addl(int l) { void HP_script_set_label(int l, int pos, const char *script_pos) { int hIndex = 0; if( HPMHooks.count.HP_script_set_label_pre ) { - void (*preHookFunc) (int *l, int *pos, const char *script_pos); + void (*preHookFunc) (int *l, int *pos, const char **script_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_label_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_label_pre[hIndex].func; - preHookFunc(&l, &pos, script_pos); + preHookFunc(&l, &pos, &script_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61912,10 +62135,10 @@ void HP_script_set_label(int l, int pos, const char *script_pos) { HPMHooks.source.script.set_label(l, pos, script_pos); } if( HPMHooks.count.HP_script_set_label_post ) { - void (*postHookFunc) (int *l, int *pos, const char *script_pos); + void (*postHookFunc) (int l, int pos, const char *script_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_label_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_label_post[hIndex].func; - postHookFunc(&l, &pos, script_pos); + postHookFunc(l, pos, script_pos); } } return; @@ -61924,11 +62147,11 @@ const char* HP_script_skip_word(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_skip_word_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_word_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_skip_word_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61951,11 +62174,11 @@ int HP_script_add_word(const char *p) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_add_word_pre ) { - int (*preHookFunc) (const char *p); + int (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_word_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_word_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61978,11 +62201,11 @@ const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_cu int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_callfunc_pre ) { - const char* (*preHookFunc) (const char *p, int *require_paren, int *is_custom); + const char* (*preHookFunc) (const char **p, int *require_paren, int *is_custom); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_callfunc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_callfunc_pre[hIndex].func; - retVal___ = preHookFunc(p, &require_paren, &is_custom); + retVal___ = preHookFunc(&p, &require_paren, &is_custom); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -61993,10 +62216,10 @@ const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_cu retVal___ = HPMHooks.source.script.parse_callfunc(p, require_paren, is_custom); } if( HPMHooks.count.HP_script_parse_callfunc_post ) { - const char* (*postHookFunc) (const char* retVal___, const char *p, int *require_paren, int *is_custom); + const char* (*postHookFunc) (const char* retVal___, const char *p, int require_paren, int is_custom); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_callfunc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_parse_callfunc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, p, &require_paren, &is_custom); + retVal___ = postHookFunc(retVal___, p, require_paren, is_custom); } } return retVal___; @@ -62004,11 +62227,11 @@ const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_cu void HP_script_parse_nextline(bool first, const char *p) { int hIndex = 0; if( HPMHooks.count.HP_script_parse_nextline_pre ) { - void (*preHookFunc) (bool *first, const char *p); + void (*preHookFunc) (bool *first, const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_nextline_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_nextline_pre[hIndex].func; - preHookFunc(&first, p); + preHookFunc(&first, &p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62019,10 +62242,10 @@ void HP_script_parse_nextline(bool first, const char *p) { HPMHooks.source.script.parse_nextline(first, p); } if( HPMHooks.count.HP_script_parse_nextline_post ) { - void (*postHookFunc) (bool *first, const char *p); + void (*postHookFunc) (bool first, const char *p); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_nextline_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_parse_nextline_post[hIndex].func; - postHookFunc(&first, p); + postHookFunc(first, p); } } return; @@ -62031,11 +62254,11 @@ const char* HP_script_parse_variable(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_variable_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_variable_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_variable_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62058,11 +62281,11 @@ const char* HP_script_parse_simpleexpr(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_simpleexpr_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62081,15 +62304,149 @@ const char* HP_script_parse_simpleexpr(const char *p) { } return retVal___; } +const char* HP_script_parse_simpleexpr_paren(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_script_parse_simpleexpr_paren_pre ) { + const char* (*preHookFunc) (const char **p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_paren_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_paren_pre[hIndex].func; + retVal___ = preHookFunc(&p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.script.parse_simpleexpr_paren(p); + } + if( HPMHooks.count.HP_script_parse_simpleexpr_paren_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_paren_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_paren_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +const char* HP_script_parse_simpleexpr_number(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_script_parse_simpleexpr_number_pre ) { + const char* (*preHookFunc) (const char **p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_number_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_number_pre[hIndex].func; + retVal___ = preHookFunc(&p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.script.parse_simpleexpr_number(p); + } + if( HPMHooks.count.HP_script_parse_simpleexpr_number_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_number_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_number_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +const char* HP_script_parse_simpleexpr_string(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_script_parse_simpleexpr_string_pre ) { + const char* (*preHookFunc) (const char **p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_string_pre[hIndex].func; + retVal___ = preHookFunc(&p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.script.parse_simpleexpr_string(p); + } + if( HPMHooks.count.HP_script_parse_simpleexpr_string_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_string_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +const char* HP_script_parse_simpleexpr_name(const char *p) { + int hIndex = 0; + const char* retVal___ = NULL; + if( HPMHooks.count.HP_script_parse_simpleexpr_name_pre ) { + const char* (*preHookFunc) (const char **p); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_name_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_name_pre[hIndex].func; + retVal___ = preHookFunc(&p); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.script.parse_simpleexpr_name(p); + } + if( HPMHooks.count.HP_script_parse_simpleexpr_name_post ) { + const char* (*postHookFunc) (const char* retVal___, const char *p); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_name_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_name_post[hIndex].func; + retVal___ = postHookFunc(retVal___, p); + } + } + return retVal___; +} +void HP_script_add_translatable_string(const struct script_string_buf *string, const char *start_point) { + int hIndex = 0; + if( HPMHooks.count.HP_script_add_translatable_string_pre ) { + void (*preHookFunc) (const struct script_string_buf **string, const char **start_point); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_translatable_string_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_script_add_translatable_string_pre[hIndex].func; + preHookFunc(&string, &start_point); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.script.add_translatable_string(string, start_point); + } + if( HPMHooks.count.HP_script_add_translatable_string_post ) { + void (*postHookFunc) (const struct script_string_buf *string, const char *start_point); + for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_translatable_string_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_script_add_translatable_string_post[hIndex].func; + postHookFunc(string, start_point); + } + } + return; +} const char* HP_script_parse_expr(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_expr_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_expr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_expr_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62112,11 +62469,11 @@ const char* HP_script_parse_line(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_parse_line_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_line_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_parse_line_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62164,11 +62521,11 @@ void HP_script_read_constdb(void) { void HP_script_constdb_comment(const char *comment) { int hIndex = 0; if( HPMHooks.count.HP_script_constdb_comment_pre ) { - void (*preHookFunc) (const char *comment); + void (*preHookFunc) (const char **comment); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_constdb_comment_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_constdb_comment_pre[hIndex].func; - preHookFunc(comment); + preHookFunc(&comment); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62217,11 +62574,11 @@ const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_print_line_pre ) { - const char* (*preHookFunc) (StringBuf *buf, const char *p, const char *mark, int *line); + const char* (*preHookFunc) (StringBuf **buf, const char **p, const char **mark, int *line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_print_line_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_print_line_pre[hIndex].func; - retVal___ = preHookFunc(buf, p, mark, &line); + retVal___ = preHookFunc(&buf, &p, &mark, &line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62232,10 +62589,10 @@ const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark retVal___ = HPMHooks.source.script.print_line(buf, p, mark, line); } if( HPMHooks.count.HP_script_print_line_post ) { - const char* (*postHookFunc) (const char* retVal___, StringBuf *buf, const char *p, const char *mark, int *line); + const char* (*postHookFunc) (const char* retVal___, StringBuf *buf, const char *p, const char *mark, int line); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_print_line_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_print_line_post[hIndex].func; - retVal___ = postHookFunc(retVal___, buf, p, mark, &line); + retVal___ = postHookFunc(retVal___, buf, p, mark, line); } } return retVal___; @@ -62243,11 +62600,11 @@ const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark void HP_script_errorwarning_sub(StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) { int hIndex = 0; if( HPMHooks.count.HP_script_errorwarning_sub_pre ) { - void (*preHookFunc) (StringBuf *buf, const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*preHookFunc) (StringBuf **buf, const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_errorwarning_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_errorwarning_sub_pre[hIndex].func; - preHookFunc(buf, src, file, &start_line, error_msg, error_pos); + preHookFunc(&buf, &src, &file, &start_line, &error_msg, &error_pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62258,10 +62615,10 @@ void HP_script_errorwarning_sub(StringBuf *buf, const char *src, const char *fil HPMHooks.source.script.errorwarning_sub(buf, src, file, start_line, error_msg, error_pos); } if( HPMHooks.count.HP_script_errorwarning_sub_post ) { - void (*postHookFunc) (StringBuf *buf, const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos); + void (*postHookFunc) (StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_errorwarning_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_errorwarning_sub_post[hIndex].func; - postHookFunc(buf, src, file, &start_line, error_msg, error_pos); + postHookFunc(buf, src, file, start_line, error_msg, error_pos); } } return; @@ -62270,11 +62627,11 @@ int HP_script_set_reg(struct script_state *st, struct map_session_data *sd, int6 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_set_reg_pre ) { - int (*preHookFunc) (struct script_state *st, struct map_session_data *sd, int64 *num, const char *name, const void *value, struct reg_db *ref); + int (*preHookFunc) (struct script_state **st, struct map_session_data **sd, int64 *num, const char **name, const void **value, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_pre[hIndex].func; - retVal___ = preHookFunc(st, sd, &num, name, value, ref); + retVal___ = preHookFunc(&st, &sd, &num, &name, &value, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62285,10 +62642,10 @@ int HP_script_set_reg(struct script_state *st, struct map_session_data *sd, int6 retVal___ = HPMHooks.source.script.set_reg(st, sd, num, name, value, ref); } if( HPMHooks.count.HP_script_set_reg_post ) { - int (*postHookFunc) (int retVal___, struct script_state *st, struct map_session_data *sd, int64 *num, const char *name, const void *value, struct reg_db *ref); + int (*postHookFunc) (int retVal___, struct script_state *st, struct map_session_data *sd, int64 num, const char *name, const void *value, struct reg_db *ref); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_post[hIndex].func; - retVal___ = postHookFunc(retVal___, st, sd, &num, name, value, ref); + retVal___ = postHookFunc(retVal___, st, sd, num, name, value, ref); } } return retVal___; @@ -62296,11 +62653,11 @@ int HP_script_set_reg(struct script_state *st, struct map_session_data *sd, int6 void HP_script_set_reg_ref_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_ref_str_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_ref_str_pre[hIndex].func; - preHookFunc(st, n, &num, name, str); + preHookFunc(&st, &n, &num, &name, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62311,10 +62668,10 @@ void HP_script_set_reg_ref_str(struct script_state *st, struct reg_db *n, int64 HPMHooks.source.script.set_reg_ref_str(st, n, num, name, str); } if( HPMHooks.count.HP_script_set_reg_ref_str_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_ref_str_post[hIndex].func; - postHookFunc(st, n, &num, name, str); + postHookFunc(st, n, num, name, str); } } return; @@ -62322,11 +62679,11 @@ void HP_script_set_reg_ref_str(struct script_state *st, struct reg_db *n, int64 void HP_script_set_reg_scope_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_scope_str_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_scope_str_pre[hIndex].func; - preHookFunc(st, n, &num, name, str); + preHookFunc(&st, &n, &num, &name, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62337,10 +62694,10 @@ void HP_script_set_reg_scope_str(struct script_state *st, struct reg_db *n, int6 HPMHooks.source.script.set_reg_scope_str(st, n, num, name, str); } if( HPMHooks.count.HP_script_set_reg_scope_str_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_scope_str_post[hIndex].func; - postHookFunc(st, n, &num, name, str); + postHookFunc(st, n, num, name, str); } } return; @@ -62348,11 +62705,11 @@ void HP_script_set_reg_scope_str(struct script_state *st, struct reg_db *n, int6 void HP_script_set_reg_npc_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_npc_str_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_npc_str_pre[hIndex].func; - preHookFunc(st, n, &num, name, str); + preHookFunc(&st, &n, &num, &name, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62363,10 +62720,10 @@ void HP_script_set_reg_npc_str(struct script_state *st, struct reg_db *n, int64 HPMHooks.source.script.set_reg_npc_str(st, n, num, name, str); } if( HPMHooks.count.HP_script_set_reg_npc_str_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, const char *str); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_npc_str_post[hIndex].func; - postHookFunc(st, n, &num, name, str); + postHookFunc(st, n, num, name, str); } } return; @@ -62374,11 +62731,11 @@ void HP_script_set_reg_npc_str(struct script_state *st, struct reg_db *n, int64 void HP_script_set_reg_instance_str(struct script_state *st, int64 num, const char *name, const char *str) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_instance_str_pre ) { - void (*preHookFunc) (struct script_state *st, int64 *num, const char *name, const char *str); + void (*preHookFunc) (struct script_state **st, int64 *num, const char **name, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_instance_str_pre[hIndex].func; - preHookFunc(st, &num, name, str); + preHookFunc(&st, &num, &name, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62389,10 +62746,10 @@ void HP_script_set_reg_instance_str(struct script_state *st, int64 num, const ch HPMHooks.source.script.set_reg_instance_str(st, num, name, str); } if( HPMHooks.count.HP_script_set_reg_instance_str_post ) { - void (*postHookFunc) (struct script_state *st, int64 *num, const char *name, const char *str); + void (*postHookFunc) (struct script_state *st, int64 num, const char *name, const char *str); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_instance_str_post[hIndex].func; - postHookFunc(st, &num, name, str); + postHookFunc(st, num, name, str); } } return; @@ -62400,11 +62757,11 @@ void HP_script_set_reg_instance_str(struct script_state *st, int64 num, const ch void HP_script_set_reg_ref_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_ref_num_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_ref_num_pre[hIndex].func; - preHookFunc(st, n, &num, name, &val); + preHookFunc(&st, &n, &num, &name, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62415,10 +62772,10 @@ void HP_script_set_reg_ref_num(struct script_state *st, struct reg_db *n, int64 HPMHooks.source.script.set_reg_ref_num(st, n, num, name, val); } if( HPMHooks.count.HP_script_set_reg_ref_num_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_ref_num_post[hIndex].func; - postHookFunc(st, n, &num, name, &val); + postHookFunc(st, n, num, name, val); } } return; @@ -62426,11 +62783,11 @@ void HP_script_set_reg_ref_num(struct script_state *st, struct reg_db *n, int64 void HP_script_set_reg_scope_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_scope_num_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_scope_num_pre[hIndex].func; - preHookFunc(st, n, &num, name, &val); + preHookFunc(&st, &n, &num, &name, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62441,10 +62798,10 @@ void HP_script_set_reg_scope_num(struct script_state *st, struct reg_db *n, int6 HPMHooks.source.script.set_reg_scope_num(st, n, num, name, val); } if( HPMHooks.count.HP_script_set_reg_scope_num_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_scope_num_post[hIndex].func; - postHookFunc(st, n, &num, name, &val); + postHookFunc(st, n, num, name, val); } } return; @@ -62452,11 +62809,11 @@ void HP_script_set_reg_scope_num(struct script_state *st, struct reg_db *n, int6 void HP_script_set_reg_npc_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_npc_num_pre ) { - void (*preHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_npc_num_pre[hIndex].func; - preHookFunc(st, n, &num, name, &val); + preHookFunc(&st, &n, &num, &name, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62467,10 +62824,10 @@ void HP_script_set_reg_npc_num(struct script_state *st, struct reg_db *n, int64 HPMHooks.source.script.set_reg_npc_num(st, n, num, name, val); } if( HPMHooks.count.HP_script_set_reg_npc_num_post ) { - void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 *num, const char *name, int *val); + void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_npc_num_post[hIndex].func; - postHookFunc(st, n, &num, name, &val); + postHookFunc(st, n, num, name, val); } } return; @@ -62478,11 +62835,11 @@ void HP_script_set_reg_npc_num(struct script_state *st, struct reg_db *n, int64 void HP_script_set_reg_instance_num(struct script_state *st, int64 num, const char *name, int val) { int hIndex = 0; if( HPMHooks.count.HP_script_set_reg_instance_num_pre ) { - void (*preHookFunc) (struct script_state *st, int64 *num, const char *name, int *val); + void (*preHookFunc) (struct script_state **st, int64 *num, const char **name, int *val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_set_reg_instance_num_pre[hIndex].func; - preHookFunc(st, &num, name, &val); + preHookFunc(&st, &num, &name, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62493,10 +62850,10 @@ void HP_script_set_reg_instance_num(struct script_state *st, int64 num, const ch HPMHooks.source.script.set_reg_instance_num(st, num, name, val); } if( HPMHooks.count.HP_script_set_reg_instance_num_post ) { - void (*postHookFunc) (struct script_state *st, int64 *num, const char *name, int *val); + void (*postHookFunc) (struct script_state *st, int64 num, const char *name, int val); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_set_reg_instance_num_post[hIndex].func; - postHookFunc(st, &num, name, &val); + postHookFunc(st, num, name, val); } } return; @@ -62504,11 +62861,11 @@ void HP_script_set_reg_instance_num(struct script_state *st, int64 num, const ch void HP_script_stack_expand(struct script_stack *stack) { int hIndex = 0; if( HPMHooks.count.HP_script_stack_expand_pre ) { - void (*preHookFunc) (struct script_stack *stack); + void (*preHookFunc) (struct script_stack **stack); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stack_expand_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_stack_expand_pre[hIndex].func; - preHookFunc(stack); + preHookFunc(&stack); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62531,11 +62888,11 @@ struct script_data* HP_script_push_retinfo(struct script_stack *stack, struct sc int hIndex = 0; struct script_data* retVal___ = NULL; if( HPMHooks.count.HP_script_push_retinfo_pre ) { - struct script_data* (*preHookFunc) (struct script_stack *stack, struct script_retinfo *ri, struct reg_db *ref); + struct script_data* (*preHookFunc) (struct script_stack **stack, struct script_retinfo **ri, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_retinfo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_push_retinfo_pre[hIndex].func; - retVal___ = preHookFunc(stack, ri, ref); + retVal___ = preHookFunc(&stack, &ri, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62557,11 +62914,11 @@ struct script_data* HP_script_push_retinfo(struct script_stack *stack, struct sc void HP_script_op_3(struct script_state *st, int op) { int hIndex = 0; if( HPMHooks.count.HP_script_op_3_pre ) { - void (*preHookFunc) (struct script_state *st, int *op); + void (*preHookFunc) (struct script_state **st, int *op); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_3_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_op_3_pre[hIndex].func; - preHookFunc(st, &op); + preHookFunc(&st, &op); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62572,10 +62929,10 @@ void HP_script_op_3(struct script_state *st, int op) { HPMHooks.source.script.op_3(st, op); } if( HPMHooks.count.HP_script_op_3_post ) { - void (*postHookFunc) (struct script_state *st, int *op); + void (*postHookFunc) (struct script_state *st, int op); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_3_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op_3_post[hIndex].func; - postHookFunc(st, &op); + postHookFunc(st, op); } } return; @@ -62583,11 +62940,11 @@ void HP_script_op_3(struct script_state *st, int op) { void HP_script_op_2str(struct script_state *st, int op, const char *s1, const char *s2) { int hIndex = 0; if( HPMHooks.count.HP_script_op_2str_pre ) { - void (*preHookFunc) (struct script_state *st, int *op, const char *s1, const char *s2); + void (*preHookFunc) (struct script_state **st, int *op, const char **s1, const char **s2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_op_2str_pre[hIndex].func; - preHookFunc(st, &op, s1, s2); + preHookFunc(&st, &op, &s1, &s2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62598,10 +62955,10 @@ void HP_script_op_2str(struct script_state *st, int op, const char *s1, const ch HPMHooks.source.script.op_2str(st, op, s1, s2); } if( HPMHooks.count.HP_script_op_2str_post ) { - void (*postHookFunc) (struct script_state *st, int *op, const char *s1, const char *s2); + void (*postHookFunc) (struct script_state *st, int op, const char *s1, const char *s2); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op_2str_post[hIndex].func; - postHookFunc(st, &op, s1, s2); + postHookFunc(st, op, s1, s2); } } return; @@ -62609,11 +62966,11 @@ void HP_script_op_2str(struct script_state *st, int op, const char *s1, const ch void HP_script_op_2num(struct script_state *st, int op, int i1, int i2) { int hIndex = 0; if( HPMHooks.count.HP_script_op_2num_pre ) { - void (*preHookFunc) (struct script_state *st, int *op, int *i1, int *i2); + void (*preHookFunc) (struct script_state **st, int *op, int *i1, int *i2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2num_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_op_2num_pre[hIndex].func; - preHookFunc(st, &op, &i1, &i2); + preHookFunc(&st, &op, &i1, &i2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62624,10 +62981,10 @@ void HP_script_op_2num(struct script_state *st, int op, int i1, int i2) { HPMHooks.source.script.op_2num(st, op, i1, i2); } if( HPMHooks.count.HP_script_op_2num_post ) { - void (*postHookFunc) (struct script_state *st, int *op, int *i1, int *i2); + void (*postHookFunc) (struct script_state *st, int op, int i1, int i2); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op_2num_post[hIndex].func; - postHookFunc(st, &op, &i1, &i2); + postHookFunc(st, op, i1, i2); } } return; @@ -62635,11 +62992,11 @@ void HP_script_op_2num(struct script_state *st, int op, int i1, int i2) { void HP_script_op_2(struct script_state *st, int op) { int hIndex = 0; if( HPMHooks.count.HP_script_op_2_pre ) { - void (*preHookFunc) (struct script_state *st, int *op); + void (*preHookFunc) (struct script_state **st, int *op); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_op_2_pre[hIndex].func; - preHookFunc(st, &op); + preHookFunc(&st, &op); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62650,10 +63007,10 @@ void HP_script_op_2(struct script_state *st, int op) { HPMHooks.source.script.op_2(st, op); } if( HPMHooks.count.HP_script_op_2_post ) { - void (*postHookFunc) (struct script_state *st, int *op); + void (*postHookFunc) (struct script_state *st, int op); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op_2_post[hIndex].func; - postHookFunc(st, &op); + postHookFunc(st, op); } } return; @@ -62661,11 +63018,11 @@ void HP_script_op_2(struct script_state *st, int op) { void HP_script_op_1(struct script_state *st, int op) { int hIndex = 0; if( HPMHooks.count.HP_script_op_1_pre ) { - void (*preHookFunc) (struct script_state *st, int *op); + void (*preHookFunc) (struct script_state **st, int *op); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_1_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_op_1_pre[hIndex].func; - preHookFunc(st, &op); + preHookFunc(&st, &op); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62676,48 +63033,49 @@ void HP_script_op_1(struct script_state *st, int op) { HPMHooks.source.script.op_1(st, op); } if( HPMHooks.count.HP_script_op_1_post ) { - void (*postHookFunc) (struct script_state *st, int *op); + void (*postHookFunc) (struct script_state *st, int op); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_1_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_op_1_post[hIndex].func; - postHookFunc(st, &op); + postHookFunc(st, op); } } return; } -void HP_script_check_buildin_argtype(struct script_state *st, int func) { +bool HP_script_check_buildin_argtype(struct script_state *st, int func) { int hIndex = 0; + bool retVal___ = false; if( HPMHooks.count.HP_script_check_buildin_argtype_pre ) { - void (*preHookFunc) (struct script_state *st, int *func); + bool (*preHookFunc) (struct script_state **st, int *func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_buildin_argtype_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_check_buildin_argtype_pre[hIndex].func; - preHookFunc(st, &func); + retVal___ = preHookFunc(&st, &func); } if( *HPMforce_return ) { *HPMforce_return = false; - return; + return retVal___; } } { - HPMHooks.source.script.check_buildin_argtype(st, func); + retVal___ = HPMHooks.source.script.check_buildin_argtype(st, func); } if( HPMHooks.count.HP_script_check_buildin_argtype_post ) { - void (*postHookFunc) (struct script_state *st, int *func); + bool (*postHookFunc) (bool retVal___, struct script_state *st, int func); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_buildin_argtype_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_check_buildin_argtype_post[hIndex].func; - postHookFunc(st, &func); + retVal___ = postHookFunc(retVal___, st, func); } } - return; + return retVal___; } void HP_script_detach_state(struct script_state *st, bool dequeue_event) { int hIndex = 0; if( HPMHooks.count.HP_script_detach_state_pre ) { - void (*preHookFunc) (struct script_state *st, bool *dequeue_event); + void (*preHookFunc) (struct script_state **st, bool *dequeue_event); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_state_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_detach_state_pre[hIndex].func; - preHookFunc(st, &dequeue_event); + preHookFunc(&st, &dequeue_event); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62728,10 +63086,10 @@ void HP_script_detach_state(struct script_state *st, bool dequeue_event) { HPMHooks.source.script.detach_state(st, dequeue_event); } if( HPMHooks.count.HP_script_detach_state_post ) { - void (*postHookFunc) (struct script_state *st, bool *dequeue_event); + void (*postHookFunc) (struct script_state *st, bool dequeue_event); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_state_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_detach_state_post[hIndex].func; - postHookFunc(st, &dequeue_event); + postHookFunc(st, dequeue_event); } } return; @@ -62740,12 +63098,12 @@ int HP_script_db_free_code_sub(union DBKey key, struct DBData *data, va_list ap) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_db_free_code_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_db_free_code_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_db_free_code_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -62759,11 +63117,11 @@ int HP_script_db_free_code_sub(union DBKey key, struct DBData *data, va_list ap) va_end(ap___copy); } if( HPMHooks.count.HP_script_db_free_code_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_db_free_code_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_script_db_free_code_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -62772,11 +63130,11 @@ int HP_script_db_free_code_sub(union DBKey key, struct DBData *data, va_list ap) void HP_script_add_autobonus(const char *autobonus) { int hIndex = 0; if( HPMHooks.count.HP_script_add_autobonus_pre ) { - void (*preHookFunc) (const char *autobonus); + void (*preHookFunc) (const char **autobonus); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_autobonus_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_autobonus_pre[hIndex].func; - preHookFunc(autobonus); + preHookFunc(&autobonus); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62799,11 +63157,11 @@ int HP_script_menu_countoptions(const char *str, int max_count, int *total) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_menu_countoptions_pre ) { - int (*preHookFunc) (const char *str, int *max_count, int *total); + int (*preHookFunc) (const char **str, int *max_count, int **total); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_menu_countoptions_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_menu_countoptions_pre[hIndex].func; - retVal___ = preHookFunc(str, &max_count, total); + retVal___ = preHookFunc(&str, &max_count, &total); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62814,10 +63172,10 @@ int HP_script_menu_countoptions(const char *str, int max_count, int *total) { retVal___ = HPMHooks.source.script.menu_countoptions(str, max_count, total); } if( HPMHooks.count.HP_script_menu_countoptions_post ) { - int (*postHookFunc) (int retVal___, const char *str, int *max_count, int *total); + int (*postHookFunc) (int retVal___, const char *str, int max_count, int *total); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_menu_countoptions_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_menu_countoptions_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &max_count, total); + retVal___ = postHookFunc(retVal___, str, max_count, total); } } return retVal___; @@ -62826,12 +63184,12 @@ int HP_script_buildin_areawarp_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_areawarp_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areawarp_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_areawarp_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -62859,12 +63217,12 @@ int HP_script_buildin_areapercentheal_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_areapercentheal_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areapercentheal_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_areapercentheal_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -62891,11 +63249,11 @@ int HP_script_buildin_areapercentheal_sub(struct block_list *bl, va_list ap) { void HP_script_buildin_delitem_delete(struct map_session_data *sd, int idx, int *amount, bool delete_items) { int hIndex = 0; if( HPMHooks.count.HP_script_buildin_delitem_delete_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount, bool *delete_items); + void (*preHookFunc) (struct map_session_data **sd, int *idx, int **amount, bool *delete_items); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_buildin_delitem_delete_pre[hIndex].func; - preHookFunc(sd, &idx, amount, &delete_items); + preHookFunc(&sd, &idx, &amount, &delete_items); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62906,10 +63264,10 @@ void HP_script_buildin_delitem_delete(struct map_session_data *sd, int idx, int HPMHooks.source.script.buildin_delitem_delete(sd, idx, amount, delete_items); } if( HPMHooks.count.HP_script_buildin_delitem_delete_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx, int *amount, bool *delete_items); + void (*postHookFunc) (struct map_session_data *sd, int idx, int *amount, bool delete_items); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_buildin_delitem_delete_post[hIndex].func; - postHookFunc(sd, &idx, amount, &delete_items); + postHookFunc(sd, idx, amount, delete_items); } } return; @@ -62918,11 +63276,11 @@ bool HP_script_buildin_delitem_search(struct map_session_data *sd, struct item * int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_script_buildin_delitem_search_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, struct item *it, bool *exact_match); + bool (*preHookFunc) (struct map_session_data **sd, struct item **it, bool *exact_match); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_buildin_delitem_search_pre[hIndex].func; - retVal___ = preHookFunc(sd, it, &exact_match); + retVal___ = preHookFunc(&sd, &it, &exact_match); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -62933,10 +63291,10 @@ bool HP_script_buildin_delitem_search(struct map_session_data *sd, struct item * retVal___ = HPMHooks.source.script.buildin_delitem_search(sd, it, exact_match); } if( HPMHooks.count.HP_script_buildin_delitem_search_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct item *it, bool *exact_match); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct item *it, bool exact_match); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_buildin_delitem_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, it, &exact_match); + retVal___ = postHookFunc(retVal___, sd, it, exact_match); } } return retVal___; @@ -62945,12 +63303,12 @@ int HP_script_buildin_killmonster_sub_strip(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_killmonster_sub_strip_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_strip_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_strip_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -62978,12 +63336,12 @@ int HP_script_buildin_killmonster_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_killmonster_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63011,12 +63369,12 @@ int HP_script_buildin_killmonsterall_sub_strip(struct block_list *bl, va_list ap int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_strip_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63044,12 +63402,12 @@ int HP_script_buildin_killmonsterall_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63077,12 +63435,12 @@ int HP_script_buildin_announce_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_announce_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_announce_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_announce_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63110,12 +63468,12 @@ int HP_script_buildin_getareausers_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_getareausers_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareausers_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_getareausers_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63143,12 +63501,12 @@ int HP_script_buildin_getareadropitem_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_getareadropitem_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareadropitem_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_getareadropitem_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63176,12 +63534,12 @@ int HP_script_mapflag_pvp_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_mapflag_pvp_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapflag_pvp_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_mapflag_pvp_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63209,12 +63567,12 @@ int HP_script_buildin_pvpoff_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_pvpoff_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_pvpoff_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_pvpoff_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63242,12 +63600,12 @@ int HP_script_buildin_maprespawnguildid_sub_pc(struct map_session_data *sd, va_l int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list ap); + int (*preHookFunc) (struct map_session_data **sd, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_pc_pre[hIndex].func; - retVal___ = preHookFunc(sd, ap___copy); + retVal___ = preHookFunc(&sd, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63275,12 +63633,12 @@ int HP_script_buildin_maprespawnguildid_sub_mob(struct block_list *bl, va_list a int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_mob_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63308,12 +63666,12 @@ int HP_script_buildin_mobcount_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_mobcount_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobcount_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_mobcount_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63341,12 +63699,12 @@ int HP_script_playbgm_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_playbgm_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playbgm_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_playbgm_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63374,12 +63732,12 @@ int HP_script_playbgm_foreachpc_sub(struct map_session_data *sd, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_playbgm_foreachpc_sub_pre ) { - int (*preHookFunc) (struct map_session_data *sd, va_list args); + int (*preHookFunc) (struct map_session_data **sd, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playbgm_foreachpc_sub_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_script_playbgm_foreachpc_sub_pre[hIndex].func; - retVal___ = preHookFunc(sd, args___copy); + retVal___ = preHookFunc(&sd, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -63407,12 +63765,12 @@ int HP_script_soundeffect_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_soundeffect_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_soundeffect_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_soundeffect_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63440,11 +63798,11 @@ int HP_script_buildin_query_sql_sub(struct script_state *st, struct Sql *handle) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_query_sql_sub_pre ) { - int (*preHookFunc) (struct script_state *st, struct Sql *handle); + int (*preHookFunc) (struct script_state **st, struct Sql **handle); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_query_sql_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_buildin_query_sql_sub_pre[hIndex].func; - retVal___ = preHookFunc(st, handle); + retVal___ = preHookFunc(&st, &handle); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63467,12 +63825,12 @@ int HP_script_buildin_instance_warpall_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_instance_warpall_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_instance_warpall_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_instance_warpall_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63500,12 +63858,12 @@ int HP_script_buildin_mobuseskill_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_buildin_mobuseskill_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobuseskill_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_buildin_mobuseskill_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63533,12 +63891,12 @@ int HP_script_cleanfloor_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_cleanfloor_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleanfloor_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_cleanfloor_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63566,11 +63924,11 @@ int HP_script_run_func(struct script_state *st) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_run_func_pre ) { - int (*preHookFunc) (struct script_state *st); + int (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_func_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_func_pre[hIndex].func; - retVal___ = preHookFunc(st); + retVal___ = preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63593,11 +63951,11 @@ const char* HP_script_getfuncname(struct script_state *st) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_getfuncname_pre ) { - const char* (*preHookFunc) (struct script_state *st); + const char* (*preHookFunc) (struct script_state **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_getfuncname_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_getfuncname_pre[hIndex].func; - retVal___ = preHookFunc(st); + retVal___ = preHookFunc(&st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63620,11 +63978,11 @@ unsigned int HP_script_calc_hash_ci(const char *p) { int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_script_calc_hash_ci_pre ) { - unsigned int (*preHookFunc) (const char *p); + unsigned int (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_ci_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_calc_hash_ci_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63647,11 +64005,11 @@ struct reg_db* HP_script_array_src(struct script_state *st, struct map_session_d int hIndex = 0; struct reg_db* retVal___ = NULL; if( HPMHooks.count.HP_script_array_src_pre ) { - struct reg_db* (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); + struct reg_db* (*preHookFunc) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_src_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_src_pre[hIndex].func; - retVal___ = preHookFunc(st, sd, name, ref); + retVal___ = preHookFunc(&st, &sd, &name, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63673,11 +64031,11 @@ struct reg_db* HP_script_array_src(struct script_state *st, struct map_session_d void HP_script_array_update(struct reg_db *src, int64 num, bool empty) { int hIndex = 0; if( HPMHooks.count.HP_script_array_update_pre ) { - void (*preHookFunc) (struct reg_db *src, int64 *num, bool *empty); + void (*preHookFunc) (struct reg_db **src, int64 *num, bool *empty); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_update_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_update_pre[hIndex].func; - preHookFunc(src, &num, &empty); + preHookFunc(&src, &num, &empty); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63688,10 +64046,10 @@ void HP_script_array_update(struct reg_db *src, int64 num, bool empty) { HPMHooks.source.script.array_update(src, num, empty); } if( HPMHooks.count.HP_script_array_update_post ) { - void (*postHookFunc) (struct reg_db *src, int64 *num, bool *empty); + void (*postHookFunc) (struct reg_db *src, int64 num, bool empty); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_update_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_array_update_post[hIndex].func; - postHookFunc(src, &num, &empty); + postHookFunc(src, num, empty); } } return; @@ -63699,11 +64057,11 @@ void HP_script_array_update(struct reg_db *src, int64 num, bool empty) { void HP_script_array_delete(struct reg_db *src, struct script_array *sa) { int hIndex = 0; if( HPMHooks.count.HP_script_array_delete_pre ) { - void (*preHookFunc) (struct reg_db *src, struct script_array *sa); + void (*preHookFunc) (struct reg_db **src, struct script_array **sa); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_delete_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_delete_pre[hIndex].func; - preHookFunc(src, sa); + preHookFunc(&src, &sa); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63725,11 +64083,11 @@ void HP_script_array_delete(struct reg_db *src, struct script_array *sa) { void HP_script_array_remove_member(struct reg_db *src, struct script_array *sa, unsigned int idx) { int hIndex = 0; if( HPMHooks.count.HP_script_array_remove_member_pre ) { - void (*preHookFunc) (struct reg_db *src, struct script_array *sa, unsigned int *idx); + void (*preHookFunc) (struct reg_db **src, struct script_array **sa, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_remove_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_remove_member_pre[hIndex].func; - preHookFunc(src, sa, &idx); + preHookFunc(&src, &sa, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63740,10 +64098,10 @@ void HP_script_array_remove_member(struct reg_db *src, struct script_array *sa, HPMHooks.source.script.array_remove_member(src, sa, idx); } if( HPMHooks.count.HP_script_array_remove_member_post ) { - void (*postHookFunc) (struct reg_db *src, struct script_array *sa, unsigned int *idx); + void (*postHookFunc) (struct reg_db *src, struct script_array *sa, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_remove_member_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_array_remove_member_post[hIndex].func; - postHookFunc(src, sa, &idx); + postHookFunc(src, sa, idx); } } return; @@ -63751,11 +64109,11 @@ void HP_script_array_remove_member(struct reg_db *src, struct script_array *sa, void HP_script_array_add_member(struct script_array *sa, unsigned int idx) { int hIndex = 0; if( HPMHooks.count.HP_script_array_add_member_pre ) { - void (*preHookFunc) (struct script_array *sa, unsigned int *idx); + void (*preHookFunc) (struct script_array **sa, unsigned int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_add_member_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_add_member_pre[hIndex].func; - preHookFunc(sa, &idx); + preHookFunc(&sa, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63766,10 +64124,10 @@ void HP_script_array_add_member(struct script_array *sa, unsigned int idx) { HPMHooks.source.script.array_add_member(sa, idx); } if( HPMHooks.count.HP_script_array_add_member_post ) { - void (*postHookFunc) (struct script_array *sa, unsigned int *idx); + void (*postHookFunc) (struct script_array *sa, unsigned int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_add_member_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_array_add_member_post[hIndex].func; - postHookFunc(sa, &idx); + postHookFunc(sa, idx); } } return; @@ -63778,11 +64136,11 @@ unsigned int HP_script_array_size(struct script_state *st, struct map_session_da int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_script_array_size_pre ) { - unsigned int (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); + unsigned int (*preHookFunc) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_size_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_size_pre[hIndex].func; - retVal___ = preHookFunc(st, sd, name, ref); + retVal___ = preHookFunc(&st, &sd, &name, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63805,11 +64163,11 @@ unsigned int HP_script_array_highest_key(struct script_state *st, struct map_ses int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_script_array_highest_key_pre ) { - unsigned int (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref); + unsigned int (*preHookFunc) (struct script_state **st, struct map_session_data **sd, const char **name, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_highest_key_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_highest_key_pre[hIndex].func; - retVal___ = preHookFunc(st, sd, name, ref); + retVal___ = preHookFunc(&st, &sd, &name, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63832,12 +64190,12 @@ int HP_script_array_free_db(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_array_free_db_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_free_db_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_array_free_db_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63851,11 +64209,11 @@ int HP_script_array_free_db(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_script_array_free_db_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_free_db_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_script_array_free_db_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -63864,11 +64222,11 @@ int HP_script_array_free_db(union DBKey key, struct DBData *data, va_list ap) { void HP_script_array_ensure_zero(struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref) { int hIndex = 0; if( HPMHooks.count.HP_script_array_ensure_zero_pre ) { - void (*preHookFunc) (struct script_state *st, struct map_session_data *sd, int64 *uid, struct reg_db *ref); + void (*preHookFunc) (struct script_state **st, struct map_session_data **sd, int64 *uid, struct reg_db **ref); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_ensure_zero_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_ensure_zero_pre[hIndex].func; - preHookFunc(st, sd, &uid, ref); + preHookFunc(&st, &sd, &uid, &ref); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63879,10 +64237,10 @@ void HP_script_array_ensure_zero(struct script_state *st, struct map_session_dat HPMHooks.source.script.array_ensure_zero(st, sd, uid, ref); } if( HPMHooks.count.HP_script_array_ensure_zero_post ) { - void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, int64 *uid, struct reg_db *ref); + void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_ensure_zero_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_array_ensure_zero_post[hIndex].func; - postHookFunc(st, sd, &uid, ref); + postHookFunc(st, sd, uid, ref); } } return; @@ -63890,11 +64248,11 @@ void HP_script_array_ensure_zero(struct script_state *st, struct map_session_dat void HP_script_reg_destroy_single(struct map_session_data *sd, int64 reg, struct script_reg_state *data) { int hIndex = 0; if( HPMHooks.count.HP_script_reg_destroy_single_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int64 *reg, struct script_reg_state *data); + void (*preHookFunc) (struct map_session_data **sd, int64 *reg, struct script_reg_state **data); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_single_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_reg_destroy_single_pre[hIndex].func; - preHookFunc(sd, ®, data); + preHookFunc(&sd, ®, &data); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -63905,10 +64263,10 @@ void HP_script_reg_destroy_single(struct map_session_data *sd, int64 reg, struct HPMHooks.source.script.reg_destroy_single(sd, reg, data); } if( HPMHooks.count.HP_script_reg_destroy_single_post ) { - void (*postHookFunc) (struct map_session_data *sd, int64 *reg, struct script_reg_state *data); + void (*postHookFunc) (struct map_session_data *sd, int64 reg, struct script_reg_state *data); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_single_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_reg_destroy_single_post[hIndex].func; - postHookFunc(sd, ®, data); + postHookFunc(sd, reg, data); } } return; @@ -63917,12 +64275,12 @@ int HP_script_reg_destroy(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_reg_destroy_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_reg_destroy_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -63936,11 +64294,11 @@ int HP_script_reg_destroy(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_script_reg_destroy_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_script_reg_destroy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -63964,10 +64322,10 @@ void HP_script_generic_ui_array_expand(unsigned int plus) { HPMHooks.source.script.generic_ui_array_expand(plus); } if( HPMHooks.count.HP_script_generic_ui_array_expand_post ) { - void (*postHookFunc) (unsigned int *plus); + void (*postHookFunc) (unsigned int plus); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_generic_ui_array_expand_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_generic_ui_array_expand_post[hIndex].func; - postHookFunc(&plus); + postHookFunc(plus); } } return; @@ -63976,11 +64334,11 @@ unsigned int* HP_script_array_cpy_list(struct script_array *sa) { int hIndex = 0; unsigned int* retVal___ = NULL; if( HPMHooks.count.HP_script_array_cpy_list_pre ) { - unsigned int* (*preHookFunc) (struct script_array *sa); + unsigned int* (*preHookFunc) (struct script_array **sa); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_cpy_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_array_cpy_list_pre[hIndex].func; - retVal___ = preHookFunc(sa); + retVal___ = preHookFunc(&sa); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64029,11 +64387,11 @@ unsigned short HP_script_mapindexname2id(struct script_state *st, const char *na int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_script_mapindexname2id_pre ) { - unsigned short (*preHookFunc) (struct script_state *st, const char *name); + unsigned short (*preHookFunc) (struct script_state **st, const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapindexname2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_mapindexname2id_pre[hIndex].func; - retVal___ = preHookFunc(st, name); + retVal___ = preHookFunc(&st, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64056,11 +64414,11 @@ int HP_script_string_dup(char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_string_dup_pre ) { - int (*preHookFunc) (char *str); + int (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_string_dup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_string_dup_pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64105,42 +64463,43 @@ void HP_script_load_translations(void) { } return; } -void HP_script_load_translation(const char *file, uint8 lang_id, uint32 *total) { +int HP_script_load_translation(const char *file, uint8 lang_id) { int hIndex = 0; + int retVal___ = 0; if( HPMHooks.count.HP_script_load_translation_pre ) { - void (*preHookFunc) (const char *file, uint8 *lang_id, uint32 *total); + int (*preHookFunc) (const char **file, uint8 *lang_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_load_translation_pre[hIndex].func; - preHookFunc(file, &lang_id, total); + retVal___ = preHookFunc(&file, &lang_id); } if( *HPMforce_return ) { *HPMforce_return = false; - return; + return retVal___; } } { - HPMHooks.source.script.load_translation(file, lang_id, total); + retVal___ = HPMHooks.source.script.load_translation(file, lang_id); } if( HPMHooks.count.HP_script_load_translation_post ) { - void (*postHookFunc) (const char *file, uint8 *lang_id, uint32 *total); + int (*postHookFunc) (int retVal___, const char *file, uint8 lang_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_load_translation_post[hIndex].func; - postHookFunc(file, &lang_id, total); + retVal___ = postHookFunc(retVal___, file, lang_id); } } - return; + return retVal___; } int HP_script_translation_db_destroyer(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_script_translation_db_destroyer_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_translation_db_destroyer_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_script_translation_db_destroyer_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -64154,11 +64513,11 @@ int HP_script_translation_db_destroyer(union DBKey key, struct DBData *data, va_ va_end(ap___copy); } if( HPMHooks.count.HP_script_translation_db_destroyer_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_translation_db_destroyer_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_script_translation_db_destroyer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -64182,10 +64541,10 @@ void HP_script_clear_translations(bool reload) { HPMHooks.source.script.clear_translations(reload); } if( HPMHooks.count.HP_script_clear_translations_post ) { - void (*postHookFunc) (bool *reload); + void (*postHookFunc) (bool reload); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_clear_translations_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_clear_translations_post[hIndex].func; - postHookFunc(&reload); + postHookFunc(reload); } } return; @@ -64209,10 +64568,10 @@ int HP_script_parse_cleanup_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.script.parse_cleanup_timer(tid, tick, id, data); } if( HPMHooks.count.HP_script_parse_cleanup_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_cleanup_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_parse_cleanup_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -64221,11 +64580,11 @@ uint8 HP_script_add_language(const char *name) { int hIndex = 0; uint8 retVal___ = 0; if( HPMHooks.count.HP_script_add_language_pre ) { - uint8 (*preHookFunc) (const char *name); + uint8 (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_language_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_add_language_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64248,11 +64607,11 @@ const char* HP_script_get_translation_file_name(const char *file) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_script_get_translation_file_name_pre ) { - const char* (*preHookFunc) (const char *file); + const char* (*preHookFunc) (const char **file); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_translation_file_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_get_translation_file_name_pre[hIndex].func; - retVal___ = preHookFunc(file); + retVal___ = preHookFunc(&file); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64300,11 +64659,11 @@ void HP_script_parser_clean_leftovers(void) { void HP_script_run_use_script(struct map_session_data *sd, struct item_data *data, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_use_script_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_use_script_pre[hIndex].func; - preHookFunc(sd, data, &oid); + preHookFunc(&sd, &data, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64315,10 +64674,10 @@ void HP_script_run_use_script(struct map_session_data *sd, struct item_data *dat HPMHooks.source.script.run_use_script(sd, data, oid); } if( HPMHooks.count.HP_script_run_use_script_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_use_script_post[hIndex].func; - postHookFunc(sd, data, &oid); + postHookFunc(sd, data, oid); } } return; @@ -64326,11 +64685,11 @@ void HP_script_run_use_script(struct map_session_data *sd, struct item_data *dat void HP_script_run_item_equip_script(struct map_session_data *sd, struct item_data *data, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_item_equip_script_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_item_equip_script_pre[hIndex].func; - preHookFunc(sd, data, &oid); + preHookFunc(&sd, &data, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64341,10 +64700,10 @@ void HP_script_run_item_equip_script(struct map_session_data *sd, struct item_da HPMHooks.source.script.run_item_equip_script(sd, data, oid); } if( HPMHooks.count.HP_script_run_item_equip_script_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_item_equip_script_post[hIndex].func; - postHookFunc(sd, data, &oid); + postHookFunc(sd, data, oid); } } return; @@ -64352,11 +64711,11 @@ void HP_script_run_item_equip_script(struct map_session_data *sd, struct item_da void HP_script_run_item_unequip_script(struct map_session_data *sd, struct item_data *data, int oid) { int hIndex = 0; if( HPMHooks.count.HP_script_run_item_unequip_script_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_pre[hIndex].func; - preHookFunc(sd, data, &oid); + preHookFunc(&sd, &data, &oid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64367,10 +64726,10 @@ void HP_script_run_item_unequip_script(struct map_session_data *sd, struct item_ HPMHooks.source.script.run_item_unequip_script(sd, data, oid); } if( HPMHooks.count.HP_script_run_item_unequip_script_post ) { - void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int *oid); + void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid); for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_post[hIndex].func; - postHookFunc(sd, data, &oid); + postHookFunc(sd, data, oid); } } return; @@ -64380,11 +64739,11 @@ bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigne int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_searchstore_open_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned int *uses, unsigned short *effect); + bool (*preHookFunc) (struct map_session_data **sd, unsigned int *uses, unsigned short *effect); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_open_pre[hIndex].func; - retVal___ = preHookFunc(sd, &uses, &effect); + retVal___ = preHookFunc(&sd, &uses, &effect); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64395,10 +64754,10 @@ bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigne retVal___ = HPMHooks.source.searchstore.open(sd, uses, effect); } if( HPMHooks.count.HP_searchstore_open_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int *uses, unsigned short *effect); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int uses, unsigned short effect); for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_open_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_searchstore_open_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &uses, &effect); + retVal___ = postHookFunc(retVal___, sd, uses, effect); } } return retVal___; @@ -64406,11 +64765,11 @@ bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigne void HP_searchstore_query(struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_query_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short *itemlist, unsigned int *item_count, const unsigned short *cardlist, unsigned int *card_count); + void (*preHookFunc) (struct map_session_data **sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short **itemlist, unsigned int *item_count, const unsigned short **cardlist, unsigned int *card_count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_query_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_query_pre[hIndex].func; - preHookFunc(sd, &type, &min_price, &max_price, itemlist, &item_count, cardlist, &card_count); + preHookFunc(&sd, &type, &min_price, &max_price, &itemlist, &item_count, &cardlist, &card_count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64421,10 +64780,10 @@ void HP_searchstore_query(struct map_session_data *sd, unsigned char type, unsig HPMHooks.source.searchstore.query(sd, type, min_price, max_price, itemlist, item_count, cardlist, card_count); } if( HPMHooks.count.HP_searchstore_query_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short *itemlist, unsigned int *item_count, const unsigned short *cardlist, unsigned int *card_count); + void (*postHookFunc) (struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count); for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_query_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_searchstore_query_post[hIndex].func; - postHookFunc(sd, &type, &min_price, &max_price, itemlist, &item_count, cardlist, &card_count); + postHookFunc(sd, type, min_price, max_price, itemlist, item_count, cardlist, card_count); } } return; @@ -64433,11 +64792,11 @@ bool HP_searchstore_querynext(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_searchstore_querynext_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_querynext_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_querynext_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64459,11 +64818,11 @@ bool HP_searchstore_querynext(struct map_session_data *sd) { void HP_searchstore_next(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_next_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_next_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_next_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64485,11 +64844,11 @@ void HP_searchstore_next(struct map_session_data *sd) { void HP_searchstore_clear(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_clear_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_clear_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64511,11 +64870,11 @@ void HP_searchstore_clear(struct map_session_data *sd) { void HP_searchstore_close(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_close_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_close_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64537,11 +64896,11 @@ void HP_searchstore_close(struct map_session_data *sd) { void HP_searchstore_click(struct map_session_data *sd, int account_id, int store_id, unsigned short nameid) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_click_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *store_id, unsigned short *nameid); + void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *store_id, unsigned short *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_click_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_click_pre[hIndex].func; - preHookFunc(sd, &account_id, &store_id, &nameid); + preHookFunc(&sd, &account_id, &store_id, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64552,10 +64911,10 @@ void HP_searchstore_click(struct map_session_data *sd, int account_id, int store HPMHooks.source.searchstore.click(sd, account_id, store_id, nameid); } if( HPMHooks.count.HP_searchstore_click_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *store_id, unsigned short *nameid); + void (*postHookFunc) (struct map_session_data *sd, int account_id, int store_id, unsigned short nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_click_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_searchstore_click_post[hIndex].func; - postHookFunc(sd, &account_id, &store_id, &nameid); + postHookFunc(sd, account_id, store_id, nameid); } } return; @@ -64564,11 +64923,11 @@ bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_searchstore_queryremote_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, int *account_id); + bool (*preHookFunc) (struct map_session_data **sd, int *account_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_queryremote_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_queryremote_pre[hIndex].func; - retVal___ = preHookFunc(sd, &account_id); + retVal___ = preHookFunc(&sd, &account_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64579,10 +64938,10 @@ bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) { retVal___ = HPMHooks.source.searchstore.queryremote(sd, account_id); } if( HPMHooks.count.HP_searchstore_queryremote_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *account_id); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int account_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_queryremote_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_searchstore_queryremote_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &account_id); + retVal___ = postHookFunc(retVal___, sd, account_id); } } return retVal___; @@ -64590,11 +64949,11 @@ bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) { void HP_searchstore_clearremote(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_searchstore_clearremote_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clearremote_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_clearremote_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64617,11 +64976,11 @@ bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, i int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_searchstore_result_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned int *store_id, int *account_id, const char *store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short *card, unsigned char *refine); + bool (*preHookFunc) (struct map_session_data **sd, unsigned int *store_id, int *account_id, const char **store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short **card, unsigned char *refine); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_result_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_searchstore_result_pre[hIndex].func; - retVal___ = preHookFunc(sd, &store_id, &account_id, store_name, &nameid, &amount, &price, card, &refine); + retVal___ = preHookFunc(&sd, &store_id, &account_id, &store_name, &nameid, &amount, &price, &card, &refine); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -64632,10 +64991,10 @@ bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, i retVal___ = HPMHooks.source.searchstore.result(sd, store_id, account_id, store_name, nameid, amount, price, card, refine); } if( HPMHooks.count.HP_searchstore_result_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int *store_id, int *account_id, const char *store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short *card, unsigned char *refine); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, unsigned short nameid, unsigned short amount, unsigned int price, const short *card, unsigned char refine); for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_result_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_searchstore_result_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &store_id, &account_id, store_name, &nameid, &amount, &price, card, &refine); + retVal___ = postHookFunc(retVal___, sd, store_id, account_id, store_name, nameid, amount, price, card, refine); } } return retVal___; @@ -64723,12 +65082,12 @@ int HP_showmsg_showMessageV(const char *string, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_showmsg_showMessageV_pre ) { - int (*preHookFunc) (const char *string, va_list ap); + int (*preHookFunc) (const char **string, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func; - retVal___ = preHookFunc(string, ap___copy); + retVal___ = preHookFunc(&string, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -64772,10 +65131,10 @@ int HP_skill_init(bool minimal) { retVal___ = HPMHooks.source.skill.init(minimal); } if( HPMHooks.count.HP_skill_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -64851,10 +65210,10 @@ void HP_skill_read_db(bool minimal) { HPMHooks.source.skill.read_db(minimal); } if( HPMHooks.count.HP_skill_read_db_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -64878,10 +65237,10 @@ int HP_skill_get_index(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_index(skill_id); } if( HPMHooks.count.HP_skill_get_index_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_index_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_index_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -64905,10 +65264,10 @@ int HP_skill_get_type(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_type(skill_id); } if( HPMHooks.count.HP_skill_get_type_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -64932,10 +65291,10 @@ int HP_skill_get_hit(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_hit(skill_id); } if( HPMHooks.count.HP_skill_get_hit_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_hit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -64959,10 +65318,10 @@ int HP_skill_get_inf(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_inf(skill_id); } if( HPMHooks.count.HP_skill_get_inf_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_inf_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -64986,10 +65345,10 @@ int HP_skill_get_ele(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_ele(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_ele_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ele_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_ele_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65013,10 +65372,10 @@ int HP_skill_get_nk(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_nk(skill_id); } if( HPMHooks.count.HP_skill_get_nk_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_nk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_nk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65040,10 +65399,10 @@ int HP_skill_get_max(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_max(skill_id); } if( HPMHooks.count.HP_skill_get_max_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_max_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_max_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65067,10 +65426,10 @@ int HP_skill_get_range(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_range(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_range_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_range_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65079,11 +65438,11 @@ int HP_skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_get_range2_pre ) { - int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_range2_pre[hIndex].func; - retVal___ = preHookFunc(bl, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -65094,10 +65453,10 @@ int HP_skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv) retVal___ = HPMHooks.source.skill.get_range2(bl, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_range2_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_range2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv); } } return retVal___; @@ -65121,10 +65480,10 @@ int HP_skill_get_splash(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_splash(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_splash_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_splash_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_splash_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65148,10 +65507,10 @@ int HP_skill_get_hp(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_hp(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_hp_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_hp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65175,10 +65534,10 @@ int HP_skill_get_mhp(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_mhp(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_mhp_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_mhp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_mhp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65202,10 +65561,10 @@ int HP_skill_get_sp(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_sp(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_sp_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_sp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_sp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65229,10 +65588,10 @@ int HP_skill_get_state(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_state(skill_id); } if( HPMHooks.count.HP_skill_get_state_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_state_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_state_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65256,10 +65615,10 @@ int HP_skill_get_spiritball(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_spiritball(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_spiritball_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_spiritball_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_spiritball_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65283,10 +65642,10 @@ int HP_skill_get_zeny(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_zeny(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_zeny_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_zeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_zeny_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65310,10 +65669,10 @@ int HP_skill_get_num(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_num(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_num_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_num_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_num_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65337,10 +65696,10 @@ int HP_skill_get_cast(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_cast(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_cast_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_cast_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65364,10 +65723,10 @@ int HP_skill_get_delay(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_delay(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_delay_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_delay_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65391,10 +65750,10 @@ int HP_skill_get_walkdelay(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_walkdelay(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_walkdelay_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_walkdelay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_walkdelay_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65418,10 +65777,10 @@ int HP_skill_get_time(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_time(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_time_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_time_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65445,10 +65804,10 @@ int HP_skill_get_time2(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_time2(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_time2_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_time2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65472,10 +65831,10 @@ int HP_skill_get_castnodex(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_castnodex(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_castnodex_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castnodex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_castnodex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65499,10 +65858,10 @@ int HP_skill_get_delaynodex(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_delaynodex(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_delaynodex_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delaynodex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_delaynodex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65526,10 +65885,10 @@ int HP_skill_get_castdef(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_castdef(skill_id); } if( HPMHooks.count.HP_skill_get_castdef_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castdef_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_castdef_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65553,10 +65912,10 @@ int HP_skill_get_weapontype(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_weapontype(skill_id); } if( HPMHooks.count.HP_skill_get_weapontype_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_weapontype_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_weapontype_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65580,10 +65939,10 @@ int HP_skill_get_ammotype(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_ammotype(skill_id); } if( HPMHooks.count.HP_skill_get_ammotype_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammotype_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_ammotype_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65607,10 +65966,10 @@ int HP_skill_get_ammo_qty(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_ammo_qty(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_ammo_qty_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammo_qty_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_ammo_qty_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65634,10 +65993,10 @@ int HP_skill_get_unit_id(uint16 skill_id, int flag) { retVal___ = HPMHooks.source.skill.get_unit_id(skill_id, flag); } if( HPMHooks.count.HP_skill_get_unit_id_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, int *flag); + int (*postHookFunc) (int retVal___, uint16 skill_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &flag); + retVal___ = postHookFunc(retVal___, skill_id, flag); } } return retVal___; @@ -65661,10 +66020,10 @@ int HP_skill_get_inf2(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_inf2(skill_id); } if( HPMHooks.count.HP_skill_get_inf2_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_inf2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65688,10 +66047,10 @@ int HP_skill_get_castcancel(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_castcancel(skill_id); } if( HPMHooks.count.HP_skill_get_castcancel_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castcancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_castcancel_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65715,10 +66074,10 @@ int HP_skill_get_maxcount(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_maxcount(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_maxcount_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_maxcount_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_maxcount_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65742,10 +66101,10 @@ int HP_skill_get_blewcount(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_blewcount(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_blewcount_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_blewcount_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_blewcount_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65769,10 +66128,10 @@ int HP_skill_get_unit_flag(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_unit_flag(skill_id); } if( HPMHooks.count.HP_skill_get_unit_flag_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_flag_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_flag_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65796,10 +66155,10 @@ int HP_skill_get_unit_target(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_unit_target(skill_id); } if( HPMHooks.count.HP_skill_get_unit_target_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_target_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_target_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65823,10 +66182,10 @@ int HP_skill_get_unit_interval(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_unit_interval(skill_id); } if( HPMHooks.count.HP_skill_get_unit_interval_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_interval_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_interval_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65850,10 +66209,10 @@ int HP_skill_get_unit_bl_target(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_unit_bl_target(skill_id); } if( HPMHooks.count.HP_skill_get_unit_bl_target_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_bl_target_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_bl_target_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -65877,10 +66236,10 @@ int HP_skill_get_unit_layout_type(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_unit_layout_type(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_unit_layout_type_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65904,10 +66263,10 @@ int HP_skill_get_unit_range(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_unit_range(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_unit_range_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_range_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_range_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65931,10 +66290,10 @@ int HP_skill_get_cooldown(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_cooldown(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_cooldown_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cooldown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_cooldown_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -65958,10 +66317,10 @@ int HP_skill_tree_get_max(uint16 skill_id, int b_class) { retVal___ = HPMHooks.source.skill.tree_get_max(skill_id, b_class); } if( HPMHooks.count.HP_skill_tree_get_max_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, int *b_class); + int (*postHookFunc) (int retVal___, uint16 skill_id, int b_class); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_tree_get_max_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_tree_get_max_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &b_class); + retVal___ = postHookFunc(retVal___, skill_id, b_class); } } return retVal___; @@ -65985,10 +66344,10 @@ const char* HP_skill_get_name(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_name(skill_id); } if( HPMHooks.count.HP_skill_get_name_post ) { - const char* (*postHookFunc) (const char* retVal___, uint16 *skill_id); + const char* (*postHookFunc) (const char* retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_name_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_name_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -66012,10 +66371,10 @@ const char* HP_skill_get_desc(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_desc(skill_id); } if( HPMHooks.count.HP_skill_get_desc_post ) { - const char* (*postHookFunc) (const char* retVal___, uint16 *skill_id); + const char* (*postHookFunc) (const char* retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_desc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_desc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -66023,11 +66382,11 @@ const char* HP_skill_get_desc(uint16 skill_id) { void HP_skill_chk(uint16 *skill_id) { int hIndex = 0; if( HPMHooks.count.HP_skill_chk_pre ) { - void (*preHookFunc) (uint16 *skill_id); + void (*preHookFunc) (uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_chk_pre[hIndex].func; - preHookFunc(skill_id); + preHookFunc(&skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66065,10 +66424,10 @@ int HP_skill_get_casttype(uint16 skill_id) { retVal___ = HPMHooks.source.skill.get_casttype(skill_id); } if( HPMHooks.count.HP_skill_get_casttype_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id); + int (*postHookFunc) (int retVal___, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_casttype_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -66092,10 +66451,10 @@ int HP_skill_get_casttype2(uint16 index) { retVal___ = HPMHooks.source.skill.get_casttype2(index); } if( HPMHooks.count.HP_skill_get_casttype2_post ) { - int (*postHookFunc) (int retVal___, uint16 *index); + int (*postHookFunc) (int retVal___, uint16 index); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_casttype2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &index); + retVal___ = postHookFunc(retVal___, index); } } return retVal___; @@ -66119,10 +66478,10 @@ bool HP_skill_is_combo(int skill_id) { retVal___ = HPMHooks.source.skill.is_combo(skill_id); } if( HPMHooks.count.HP_skill_is_combo_post ) { - bool (*postHookFunc) (bool retVal___, int *skill_id); + bool (*postHookFunc) (bool retVal___, int skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_is_combo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_is_combo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -66131,11 +66490,11 @@ int HP_skill_name2id(const char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_name2id_pre ) { - int (*preHookFunc) (const char *name); + int (*preHookFunc) (const char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_name2id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_name2id_pre[hIndex].func; - retVal___ = preHookFunc(name); + retVal___ = preHookFunc(&name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66158,11 +66517,11 @@ int HP_skill_isammotype(struct map_session_data *sd, int skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_isammotype_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *skill_id); + int (*preHookFunc) (struct map_session_data **sd, int *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_isammotype_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66173,10 +66532,10 @@ int HP_skill_isammotype(struct map_session_data *sd, int skill_id) { retVal___ = HPMHooks.source.skill.isammotype(sd, skill_id); } if( HPMHooks.count.HP_skill_isammotype_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_isammotype_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -66200,10 +66559,10 @@ int HP_skill_castend_id(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.castend_id(tid, tick, id, data); } if( HPMHooks.count.HP_skill_castend_id_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -66227,10 +66586,10 @@ int HP_skill_castend_pos(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.castend_pos(tid, tick, id, data); } if( HPMHooks.count.HP_skill_castend_pos_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_pos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -66239,11 +66598,11 @@ int HP_skill_castend_map(struct map_session_data *sd, uint16 skill_id, const cha int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_castend_map_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, const char *mapname); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, const char **mapname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_map_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_map_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, mapname); + retVal___ = preHookFunc(&sd, &skill_id, &mapname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66254,10 +66613,10 @@ int HP_skill_castend_map(struct map_session_data *sd, uint16 skill_id, const cha retVal___ = HPMHooks.source.skill.castend_map(sd, skill_id, mapname); } if( HPMHooks.count.HP_skill_castend_map_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, const char *mapname); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, const char *mapname); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_map_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_map_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, mapname); + retVal___ = postHookFunc(retVal___, sd, skill_id, mapname); } } return retVal___; @@ -66266,11 +66625,11 @@ int HP_skill_cleartimerskill(struct block_list *src) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_cleartimerskill_pre ) { - int (*preHookFunc) (struct block_list *src); + int (*preHookFunc) (struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_pre[hIndex].func; - retVal___ = preHookFunc(src); + retVal___ = preHookFunc(&src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66293,11 +66652,11 @@ int HP_skill_addtimerskill(struct block_list *src, int64 tick, int target, int x int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_addtimerskill_pre ) { - int (*preHookFunc) (struct block_list *src, int64 *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag); + int (*preHookFunc) (struct block_list **src, int64 *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_addtimerskill_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_addtimerskill_pre[hIndex].func; - retVal___ = preHookFunc(src, &tick, &target, &x, &y, &skill_id, &skill_lv, &type, &flag); + retVal___ = preHookFunc(&src, &tick, &target, &x, &y, &skill_id, &skill_lv, &type, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66308,10 +66667,10 @@ int HP_skill_addtimerskill(struct block_list *src, int64 tick, int target, int x retVal___ = HPMHooks.source.skill.addtimerskill(src, tick, target, x, y, skill_id, skill_lv, type, flag); } if( HPMHooks.count.HP_skill_addtimerskill_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int64 *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, int64 tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_addtimerskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_addtimerskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &tick, &target, &x, &y, &skill_id, &skill_lv, &type, &flag); + retVal___ = postHookFunc(retVal___, src, tick, target, x, y, skill_id, skill_lv, type, flag); } } return retVal___; @@ -66320,11 +66679,11 @@ int HP_skill_additional_effect(struct block_list *src, struct block_list *bl, ui int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_additional_effect_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_additional_effect_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66335,10 +66694,10 @@ int HP_skill_additional_effect(struct block_list *src, struct block_list *bl, ui retVal___ = HPMHooks.source.skill.additional_effect(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick); } if( HPMHooks.count.HP_skill_additional_effect_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_additional_effect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick); } } return retVal___; @@ -66347,11 +66706,11 @@ int HP_skill_counter_additional_effect(struct block_list *src, struct block_list int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_counter_additional_effect_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &attack_type, &tick); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66362,10 +66721,10 @@ int HP_skill_counter_additional_effect(struct block_list *src, struct block_list retVal___ = HPMHooks.source.skill.counter_additional_effect(src, bl, skill_id, skill_lv, attack_type, tick); } if( HPMHooks.count.HP_skill_counter_additional_effect_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &attack_type, &tick); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, attack_type, tick); } } return retVal___; @@ -66374,11 +66733,11 @@ int HP_skill_blown(struct block_list *src, struct block_list *target, int count, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_blown_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, int *count, int8 *dir, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, int *count, int8 *dir, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_blown_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &count, &dir, &flag); + retVal___ = preHookFunc(&src, &target, &count, &dir, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66389,10 +66748,10 @@ int HP_skill_blown(struct block_list *src, struct block_list *target, int count, retVal___ = HPMHooks.source.skill.blown(src, target, count, dir, flag); } if( HPMHooks.count.HP_skill_blown_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int *count, int8 *dir, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int count, int8 dir, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blown_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &count, &dir, &flag); + retVal___ = postHookFunc(retVal___, src, target, count, dir, flag); } } return retVal___; @@ -66401,11 +66760,11 @@ int HP_skill_break_equip(struct block_list *bl, unsigned short where, int rate, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_break_equip_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *flag); + int (*preHookFunc) (struct block_list **bl, unsigned short *where, int *rate, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_break_equip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_break_equip_pre[hIndex].func; - retVal___ = preHookFunc(bl, &where, &rate, &flag); + retVal___ = preHookFunc(&bl, &where, &rate, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66416,10 +66775,10 @@ int HP_skill_break_equip(struct block_list *bl, unsigned short where, int rate, retVal___ = HPMHooks.source.skill.break_equip(bl, where, rate, flag); } if( HPMHooks.count.HP_skill_break_equip_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short *where, int *rate, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short where, int rate, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_break_equip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_break_equip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &where, &rate, &flag); + retVal___ = postHookFunc(retVal___, bl, where, rate, flag); } } return retVal___; @@ -66428,11 +66787,11 @@ int HP_skill_strip_equip(struct block_list *bl, unsigned short where, int rate, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_strip_equip_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *lv, int *time); + int (*preHookFunc) (struct block_list **bl, unsigned short *where, int *rate, int *lv, int *time); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_strip_equip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_strip_equip_pre[hIndex].func; - retVal___ = preHookFunc(bl, &where, &rate, &lv, &time); + retVal___ = preHookFunc(&bl, &where, &rate, &lv, &time); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66443,10 +66802,10 @@ int HP_skill_strip_equip(struct block_list *bl, unsigned short where, int rate, retVal___ = HPMHooks.source.skill.strip_equip(bl, where, rate, lv, time); } if( HPMHooks.count.HP_skill_strip_equip_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short *where, int *rate, int *lv, int *time); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short where, int rate, int lv, int time); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_strip_equip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_strip_equip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &where, &rate, &lv, &time); + retVal___ = postHookFunc(retVal___, bl, where, rate, lv, time); } } return retVal___; @@ -66470,10 +66829,10 @@ struct skill_unit_group* HP_skill_id2group(int group_id) { retVal___ = HPMHooks.source.skill.id2group(group_id); } if( HPMHooks.count.HP_skill_id2group_post ) { - struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, int *group_id); + struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, int group_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_id2group_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_id2group_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &group_id); + retVal___ = postHookFunc(retVal___, group_id); } } return retVal___; @@ -66482,11 +66841,11 @@ struct skill_unit_group* HP_skill_unitsetting(struct block_list *src, uint16 ski int hIndex = 0; struct skill_unit_group* retVal___ = NULL; if( HPMHooks.count.HP_skill_unitsetting_pre ) { - struct skill_unit_group* (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag); + struct skill_unit_group* (*preHookFunc) (struct block_list **src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unitsetting_pre[hIndex].func; - retVal___ = preHookFunc(src, &skill_id, &skill_lv, &x, &y, &flag); + retVal___ = preHookFunc(&src, &skill_id, &skill_lv, &x, &y, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66497,10 +66856,10 @@ struct skill_unit_group* HP_skill_unitsetting(struct block_list *src, uint16 ski retVal___ = HPMHooks.source.skill.unitsetting(src, skill_id, skill_lv, x, y, flag); } if( HPMHooks.count.HP_skill_unitsetting_post ) { - struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag); + struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unitsetting_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &skill_id, &skill_lv, &x, &y, &flag); + retVal___ = postHookFunc(retVal___, src, skill_id, skill_lv, x, y, flag); } } return retVal___; @@ -66509,11 +66868,11 @@ struct skill_unit* HP_skill_initunit(struct skill_unit_group *group, int idx, in int hIndex = 0; struct skill_unit* retVal___ = NULL; if( HPMHooks.count.HP_skill_initunit_pre ) { - struct skill_unit* (*preHookFunc) (struct skill_unit_group *group, int *idx, int *x, int *y, int *val1, int *val2); + struct skill_unit* (*preHookFunc) (struct skill_unit_group **group, int *idx, int *x, int *y, int *val1, int *val2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_initunit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_initunit_pre[hIndex].func; - retVal___ = preHookFunc(group, &idx, &x, &y, &val1, &val2); + retVal___ = preHookFunc(&group, &idx, &x, &y, &val1, &val2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66524,10 +66883,10 @@ struct skill_unit* HP_skill_initunit(struct skill_unit_group *group, int idx, in retVal___ = HPMHooks.source.skill.initunit(group, idx, x, y, val1, val2); } if( HPMHooks.count.HP_skill_initunit_post ) { - struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct skill_unit_group *group, int *idx, int *x, int *y, int *val1, int *val2); + struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct skill_unit_group *group, int idx, int x, int y, int val1, int val2); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_initunit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_initunit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, group, &idx, &x, &y, &val1, &val2); + retVal___ = postHookFunc(retVal___, group, idx, x, y, val1, val2); } } return retVal___; @@ -66536,11 +66895,11 @@ int HP_skill_delunit(struct skill_unit *su) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_delunit_pre ) { - int (*preHookFunc) (struct skill_unit *su); + int (*preHookFunc) (struct skill_unit **su); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delunit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_delunit_pre[hIndex].func; - retVal___ = preHookFunc(su); + retVal___ = preHookFunc(&su); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66563,11 +66922,11 @@ struct skill_unit_group* HP_skill_init_unitgroup(struct block_list *src, int cou int hIndex = 0; struct skill_unit_group* retVal___ = NULL; if( HPMHooks.count.HP_skill_init_unitgroup_pre ) { - struct skill_unit_group* (*preHookFunc) (struct block_list *src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval); + struct skill_unit_group* (*preHookFunc) (struct block_list **src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unitgroup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_init_unitgroup_pre[hIndex].func; - retVal___ = preHookFunc(src, &count, &skill_id, &skill_lv, &unit_id, &limit, &interval); + retVal___ = preHookFunc(&src, &count, &skill_id, &skill_lv, &unit_id, &limit, &interval); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66578,10 +66937,10 @@ struct skill_unit_group* HP_skill_init_unitgroup(struct block_list *src, int cou retVal___ = HPMHooks.source.skill.init_unitgroup(src, count, skill_id, skill_lv, unit_id, limit, interval); } if( HPMHooks.count.HP_skill_init_unitgroup_post ) { - struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval); + struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unitgroup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_init_unitgroup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &count, &skill_id, &skill_lv, &unit_id, &limit, &interval); + retVal___ = postHookFunc(retVal___, src, count, skill_id, skill_lv, unit_id, limit, interval); } } return retVal___; @@ -66590,11 +66949,11 @@ int HP_skill_del_unitgroup(struct skill_unit_group *group, const char *file, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_del_unitgroup_pre ) { - int (*preHookFunc) (struct skill_unit_group *group, const char *file, int *line, const char *func); + int (*preHookFunc) (struct skill_unit_group **group, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_del_unitgroup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_del_unitgroup_pre[hIndex].func; - retVal___ = preHookFunc(group, file, &line, func); + retVal___ = preHookFunc(&group, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66605,10 +66964,10 @@ int HP_skill_del_unitgroup(struct skill_unit_group *group, const char *file, int retVal___ = HPMHooks.source.skill.del_unitgroup(group, file, line, func); } if( HPMHooks.count.HP_skill_del_unitgroup_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit_group *group, const char *file, int *line, const char *func); + int (*postHookFunc) (int retVal___, struct skill_unit_group *group, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_del_unitgroup_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_del_unitgroup_post[hIndex].func; - retVal___ = postHookFunc(retVal___, group, file, &line, func); + retVal___ = postHookFunc(retVal___, group, file, line, func); } } return retVal___; @@ -66617,11 +66976,11 @@ int HP_skill_clear_unitgroup(struct block_list *src) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_clear_unitgroup_pre ) { - int (*preHookFunc) (struct block_list *src); + int (*preHookFunc) (struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_unitgroup_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_clear_unitgroup_pre[hIndex].func; - retVal___ = preHookFunc(src); + retVal___ = preHookFunc(&src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66644,11 +67003,11 @@ int HP_skill_clear_group(struct block_list *bl, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_clear_group_pre ) { - int (*preHookFunc) (struct block_list *bl, int *flag); + int (*preHookFunc) (struct block_list **bl, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_group_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_clear_group_pre[hIndex].func; - retVal___ = preHookFunc(bl, &flag); + retVal___ = preHookFunc(&bl, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66659,10 +67018,10 @@ int HP_skill_clear_group(struct block_list *bl, int flag) { retVal___ = HPMHooks.source.skill.clear_group(bl, flag); } if( HPMHooks.count.HP_skill_clear_group_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_group_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_clear_group_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &flag); + retVal___ = postHookFunc(retVal___, bl, flag); } } return retVal___; @@ -66671,11 +67030,11 @@ int HP_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 t int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_onplace_pre ) { - int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_onplace_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &tick); + retVal___ = preHookFunc(&src, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66686,10 +67045,10 @@ int HP_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 t retVal___ = HPMHooks.source.skill.unit_onplace(src, bl, tick); } if( HPMHooks.count.HP_skill_unit_onplace_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_onplace_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &tick); + retVal___ = postHookFunc(retVal___, src, bl, tick); } } return retVal___; @@ -66698,11 +67057,11 @@ int HP_skill_unit_ondamaged(struct skill_unit *src, struct block_list *bl, int64 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_ondamaged_pre ) { - int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *damage, int64 *tick); + int (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 *damage, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_ondamaged_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_ondamaged_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &damage, &tick); + retVal___ = preHookFunc(&src, &bl, &damage, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66713,10 +67072,10 @@ int HP_skill_unit_ondamaged(struct skill_unit *src, struct block_list *bl, int64 retVal___ = HPMHooks.source.skill.unit_ondamaged(src, bl, damage, tick); } if( HPMHooks.count.HP_skill_unit_ondamaged_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 *damage, int64 *tick); + int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 damage, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_ondamaged_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_ondamaged_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &damage, &tick); + retVal___ = postHookFunc(retVal___, src, bl, damage, tick); } } return retVal___; @@ -66725,11 +67084,11 @@ int HP_skill_cast_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_cast_fix_pre ) { - int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_cast_fix_pre[hIndex].func; - retVal___ = preHookFunc(bl, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66740,10 +67099,10 @@ int HP_skill_cast_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.cast_fix(bl, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_cast_fix_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_cast_fix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv); } } return retVal___; @@ -66752,11 +67111,11 @@ int HP_skill_cast_fix_sc(struct block_list *bl, int time) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_cast_fix_sc_pre ) { - int (*preHookFunc) (struct block_list *bl, int *time); + int (*preHookFunc) (struct block_list **bl, int *time); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_sc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_cast_fix_sc_pre[hIndex].func; - retVal___ = preHookFunc(bl, &time); + retVal___ = preHookFunc(&bl, &time); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66767,10 +67126,10 @@ int HP_skill_cast_fix_sc(struct block_list *bl, int time) { retVal___ = HPMHooks.source.skill.cast_fix_sc(bl, time); } if( HPMHooks.count.HP_skill_cast_fix_sc_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *time); + int (*postHookFunc) (int retVal___, struct block_list *bl, int time); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_sc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_cast_fix_sc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &time); + retVal___ = postHookFunc(retVal___, bl, time); } } return retVal___; @@ -66779,11 +67138,11 @@ int HP_skill_vf_cast_fix(struct block_list *bl, double time, uint16 skill_id, ui int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_vf_cast_fix_pre ) { - int (*preHookFunc) (struct block_list *bl, double *time, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, double *time, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_vf_cast_fix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_vf_cast_fix_pre[hIndex].func; - retVal___ = preHookFunc(bl, &time, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &time, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66794,10 +67153,10 @@ int HP_skill_vf_cast_fix(struct block_list *bl, double time, uint16 skill_id, ui retVal___ = HPMHooks.source.skill.vf_cast_fix(bl, time, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_vf_cast_fix_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, double *time, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_vf_cast_fix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_vf_cast_fix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &time, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, time, skill_id, skill_lv); } } return retVal___; @@ -66806,11 +67165,11 @@ int HP_skill_delay_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_delay_fix_pre ) { - int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delay_fix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_delay_fix_pre[hIndex].func; - retVal___ = preHookFunc(bl, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66821,10 +67180,10 @@ int HP_skill_delay_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) retVal___ = HPMHooks.source.skill.delay_fix(bl, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_delay_fix_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delay_fix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_delay_fix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv); } } return retVal___; @@ -66833,11 +67192,11 @@ int HP_skill_check_condition_castbegin(struct map_session_data *sd, uint16 skill int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castbegin_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66848,10 +67207,10 @@ int HP_skill_check_condition_castbegin(struct map_session_data *sd, uint16 skill retVal___ = HPMHooks.source.skill.check_condition_castbegin(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_check_condition_castbegin_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv); } } return retVal___; @@ -66860,11 +67219,11 @@ int HP_skill_check_condition_castend(struct map_session_data *sd, uint16 skill_i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castend_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castend_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66875,10 +67234,10 @@ int HP_skill_check_condition_castend(struct map_session_data *sd, uint16 skill_i retVal___ = HPMHooks.source.skill.check_condition_castend(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_check_condition_castend_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_condition_castend_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv); } } return retVal___; @@ -66887,11 +67246,11 @@ int HP_skill_consume_requirement(struct map_session_data *sd, uint16 skill_id, u int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_consume_requirement_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, short *type); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv, short *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_consume_requirement_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_consume_requirement_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &skill_lv, &type); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66902,24 +67261,23 @@ int HP_skill_consume_requirement(struct map_session_data *sd, uint16 skill_id, u retVal___ = HPMHooks.source.skill.consume_requirement(sd, skill_id, skill_lv, type); } if( HPMHooks.count.HP_skill_consume_requirement_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, short *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_consume_requirement_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_consume_requirement_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv, &type); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv, type); } } return retVal___; } struct skill_condition HP_skill_get_requirement(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) { int hIndex = 0; - struct skill_condition retVal___; - memset(&retVal___, '\0', sizeof(struct skill_condition)); + struct skill_condition retVal___ = { 0 }; if( HPMHooks.count.HP_skill_get_requirement_pre ) { - struct skill_condition (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + struct skill_condition (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_requirement_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &skill_lv); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66930,10 +67288,10 @@ struct skill_condition HP_skill_get_requirement(struct map_session_data *sd, uin retVal___ = HPMHooks.source.skill.get_requirement(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_requirement_post ) { - struct skill_condition (*postHookFunc) (struct skill_condition retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + struct skill_condition (*postHookFunc) (struct skill_condition retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_requirement_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv); } } return retVal___; @@ -66942,11 +67300,11 @@ int HP_skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_pc_partner_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, int *range, int *cast_flag); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 **skill_lv, int *range, int *cast_flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_pc_partner_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_pc_partner_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, skill_lv, &range, &cast_flag); + retVal___ = preHookFunc(&sd, &skill_id, &skill_lv, &range, &cast_flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66957,10 +67315,10 @@ int HP_skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint retVal___ = HPMHooks.source.skill.check_pc_partner(sd, skill_id, skill_lv, range, cast_flag); } if( HPMHooks.count.HP_skill_check_pc_partner_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, int *range, int *cast_flag); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 *skill_lv, int range, int cast_flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_pc_partner_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_pc_partner_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, skill_lv, &range, &cast_flag); + retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv, range, cast_flag); } } return retVal___; @@ -66969,11 +67327,11 @@ int HP_skill_unit_move(struct block_list *bl, int64 tick, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_move_pre ) { - int (*preHookFunc) (struct block_list *bl, int64 *tick, int *flag); + int (*preHookFunc) (struct block_list **bl, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_move_pre[hIndex].func; - retVal___ = preHookFunc(bl, &tick, &flag); + retVal___ = preHookFunc(&bl, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -66984,10 +67342,10 @@ int HP_skill_unit_move(struct block_list *bl, int64 tick, int flag) { retVal___ = HPMHooks.source.skill.unit_move(bl, tick, flag); } if( HPMHooks.count.HP_skill_unit_move_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_move_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &tick, &flag); + retVal___ = postHookFunc(retVal___, bl, tick, flag); } } return retVal___; @@ -66996,11 +67354,11 @@ int HP_skill_unit_onleft(uint16 skill_id, struct block_list *bl, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_onleft_pre ) { - int (*preHookFunc) (uint16 *skill_id, struct block_list *bl, int64 *tick); + int (*preHookFunc) (uint16 *skill_id, struct block_list **bl, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onleft_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_onleft_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, bl, &tick); + retVal___ = preHookFunc(&skill_id, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67011,10 +67369,10 @@ int HP_skill_unit_onleft(uint16 skill_id, struct block_list *bl, int64 tick) { retVal___ = HPMHooks.source.skill.unit_onleft(skill_id, bl, tick); } if( HPMHooks.count.HP_skill_unit_onleft_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, struct block_list *bl, int64 *tick); + int (*postHookFunc) (int retVal___, uint16 skill_id, struct block_list *bl, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onleft_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_onleft_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, bl, &tick); + retVal___ = postHookFunc(retVal___, skill_id, bl, tick); } } return retVal___; @@ -67023,11 +67381,11 @@ int HP_skill_unit_onout(struct skill_unit *src, struct block_list *bl, int64 tic int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_onout_pre ) { - int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_onout_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &tick); + retVal___ = preHookFunc(&src, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67038,10 +67396,10 @@ int HP_skill_unit_onout(struct skill_unit *src, struct block_list *bl, int64 tic retVal___ = HPMHooks.source.skill.unit_onout(src, bl, tick); } if( HPMHooks.count.HP_skill_unit_onout_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onout_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_onout_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &tick); + retVal___ = postHookFunc(retVal___, src, bl, tick); } } return retVal___; @@ -67050,11 +67408,11 @@ int HP_skill_unit_move_unit_group(struct skill_unit_group *group, int16 m, int16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_move_unit_group_pre ) { - int (*preHookFunc) (struct skill_unit_group *group, int16 *m, int16 *dx, int16 *dy); + int (*preHookFunc) (struct skill_unit_group **group, int16 *m, int16 *dx, int16 *dy); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_unit_group_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_move_unit_group_pre[hIndex].func; - retVal___ = preHookFunc(group, &m, &dx, &dy); + retVal___ = preHookFunc(&group, &m, &dx, &dy); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67065,10 +67423,10 @@ int HP_skill_unit_move_unit_group(struct skill_unit_group *group, int16 m, int16 retVal___ = HPMHooks.source.skill.unit_move_unit_group(group, m, dx, dy); } if( HPMHooks.count.HP_skill_unit_move_unit_group_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit_group *group, int16 *m, int16 *dx, int16 *dy); + int (*postHookFunc) (int retVal___, struct skill_unit_group *group, int16 m, int16 dx, int16 dy); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_unit_group_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_move_unit_group_post[hIndex].func; - retVal___ = postHookFunc(retVal___, group, &m, &dx, &dy); + retVal___ = postHookFunc(retVal___, group, m, dx, dy); } } return retVal___; @@ -67077,11 +67435,11 @@ int HP_skill_sit(struct map_session_data *sd, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_sit_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *type); + int (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_sit_pre[hIndex].func; - retVal___ = preHookFunc(sd, &type); + retVal___ = preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67092,10 +67450,10 @@ int HP_skill_sit(struct map_session_data *sd, int type) { retVal___ = HPMHooks.source.skill.sit(sd, type); } if( HPMHooks.count.HP_skill_sit_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_sit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &type); + retVal___ = postHookFunc(retVal___, sd, type); } } return retVal___; @@ -67103,11 +67461,11 @@ int HP_skill_sit(struct map_session_data *sd, int type) { void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) { int hIndex = 0; if( HPMHooks.count.HP_skill_brandishspear_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + void (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_brandishspear_pre[hIndex].func; - preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag); + preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67118,10 +67476,10 @@ void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint1 HPMHooks.source.skill.brandishspear(src, bl, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_brandishspear_post ) { - void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_brandishspear_post[hIndex].func; - postHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag); + postHookFunc(src, bl, skill_id, skill_lv, tick, flag); } } return; @@ -67129,11 +67487,11 @@ void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint1 void HP_skill_repairweapon(struct map_session_data *sd, int idx) { int hIndex = 0; if( HPMHooks.count.HP_skill_repairweapon_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx); + void (*preHookFunc) (struct map_session_data **sd, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_repairweapon_pre[hIndex].func; - preHookFunc(sd, &idx); + preHookFunc(&sd, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67144,10 +67502,10 @@ void HP_skill_repairweapon(struct map_session_data *sd, int idx) { HPMHooks.source.skill.repairweapon(sd, idx); } if( HPMHooks.count.HP_skill_repairweapon_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx); + void (*postHookFunc) (struct map_session_data *sd, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_repairweapon_post[hIndex].func; - postHookFunc(sd, &idx); + postHookFunc(sd, idx); } } return; @@ -67155,11 +67513,11 @@ void HP_skill_repairweapon(struct map_session_data *sd, int idx) { void HP_skill_identify(struct map_session_data *sd, int idx) { int hIndex = 0; if( HPMHooks.count.HP_skill_identify_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx); + void (*preHookFunc) (struct map_session_data **sd, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_identify_pre[hIndex].func; - preHookFunc(sd, &idx); + preHookFunc(&sd, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67170,10 +67528,10 @@ void HP_skill_identify(struct map_session_data *sd, int idx) { HPMHooks.source.skill.identify(sd, idx); } if( HPMHooks.count.HP_skill_identify_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx); + void (*postHookFunc) (struct map_session_data *sd, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_identify_post[hIndex].func; - postHookFunc(sd, &idx); + postHookFunc(sd, idx); } } return; @@ -67181,11 +67539,11 @@ void HP_skill_identify(struct map_session_data *sd, int idx) { void HP_skill_weaponrefine(struct map_session_data *sd, int idx) { int hIndex = 0; if( HPMHooks.count.HP_skill_weaponrefine_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *idx); + void (*preHookFunc) (struct map_session_data **sd, int *idx); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_weaponrefine_pre[hIndex].func; - preHookFunc(sd, &idx); + preHookFunc(&sd, &idx); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67196,10 +67554,10 @@ void HP_skill_weaponrefine(struct map_session_data *sd, int idx) { HPMHooks.source.skill.weaponrefine(sd, idx); } if( HPMHooks.count.HP_skill_weaponrefine_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *idx); + void (*postHookFunc) (struct map_session_data *sd, int idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_weaponrefine_post[hIndex].func; - postHookFunc(sd, &idx); + postHookFunc(sd, idx); } } return; @@ -67208,11 +67566,11 @@ int HP_skill_autospell(struct map_session_data *md, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_autospell_pre ) { - int (*preHookFunc) (struct map_session_data *md, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **md, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_autospell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_autospell_pre[hIndex].func; - retVal___ = preHookFunc(md, &skill_id); + retVal___ = preHookFunc(&md, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67223,10 +67581,10 @@ int HP_skill_autospell(struct map_session_data *md, uint16 skill_id) { retVal___ = HPMHooks.source.skill.autospell(md, skill_id); } if( HPMHooks.count.HP_skill_autospell_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *md, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *md, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_autospell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_autospell_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &skill_id); + retVal___ = postHookFunc(retVal___, md, skill_id); } } return retVal___; @@ -67235,11 +67593,11 @@ int HP_skill_calc_heal(struct block_list *src, struct block_list *target, uint16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_calc_heal_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, bool *heal); + int (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, bool *heal); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_calc_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_calc_heal_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &heal); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &heal); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67250,10 +67608,10 @@ int HP_skill_calc_heal(struct block_list *src, struct block_list *target, uint16 retVal___ = HPMHooks.source.skill.calc_heal(src, target, skill_id, skill_lv, heal); } if( HPMHooks.count.HP_skill_calc_heal_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, bool *heal); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_calc_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_calc_heal_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &heal); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, heal); } } return retVal___; @@ -67262,11 +67620,11 @@ bool HP_skill_check_cloaking(struct block_list *bl, struct status_change_entry * int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_check_cloaking_pre ) { - bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce); + bool (*preHookFunc) (struct block_list **bl, struct status_change_entry **sce); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_cloaking_pre[hIndex].func; - retVal___ = preHookFunc(bl, sce); + retVal___ = preHookFunc(&bl, &sce); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67289,12 +67647,12 @@ int HP_skill_check_cloaking_end(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_cloaking_end_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_end_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_check_cloaking_end_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67322,11 +67680,11 @@ bool HP_skill_can_cloak(struct map_session_data *sd) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_can_cloak_pre ) { - bool (*preHookFunc) (struct map_session_data *sd); + bool (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_cloak_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_can_cloak_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67349,11 +67707,11 @@ int HP_skill_enchant_elemental_end(struct block_list *bl, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_enchant_elemental_end_pre ) { - int (*preHookFunc) (struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_enchant_elemental_end_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_enchant_elemental_end_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type); + retVal___ = preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67364,10 +67722,10 @@ int HP_skill_enchant_elemental_end(struct block_list *bl, int type) { retVal___ = HPMHooks.source.skill.enchant_elemental_end(bl, type); } if( HPMHooks.count.HP_skill_enchant_elemental_end_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_enchant_elemental_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_enchant_elemental_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type); + retVal___ = postHookFunc(retVal___, bl, type); } } return retVal___; @@ -67376,11 +67734,11 @@ int HP_skill_not_ok(uint16 skill_id, struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_not_ok_pre ) { - int (*preHookFunc) (uint16 *skill_id, struct map_session_data *sd); + int (*preHookFunc) (uint16 *skill_id, struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_not_ok_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, sd); + retVal___ = preHookFunc(&skill_id, &sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67391,10 +67749,10 @@ int HP_skill_not_ok(uint16 skill_id, struct map_session_data *sd) { retVal___ = HPMHooks.source.skill.not_ok(skill_id, sd); } if( HPMHooks.count.HP_skill_not_ok_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, struct map_session_data *sd); + int (*postHookFunc) (int retVal___, uint16 skill_id, struct map_session_data *sd); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_not_ok_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, sd); + retVal___ = postHookFunc(retVal___, skill_id, sd); } } return retVal___; @@ -67403,11 +67761,11 @@ int HP_skill_not_ok_hom(uint16 skill_id, struct homun_data *hd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_not_ok_hom_pre ) { - int (*preHookFunc) (uint16 *skill_id, struct homun_data *hd); + int (*preHookFunc) (uint16 *skill_id, struct homun_data **hd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_not_ok_hom_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, hd); + retVal___ = preHookFunc(&skill_id, &hd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67418,10 +67776,10 @@ int HP_skill_not_ok_hom(uint16 skill_id, struct homun_data *hd) { retVal___ = HPMHooks.source.skill.not_ok_hom(skill_id, hd); } if( HPMHooks.count.HP_skill_not_ok_hom_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, struct homun_data *hd); + int (*postHookFunc) (int retVal___, uint16 skill_id, struct homun_data *hd); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_not_ok_hom_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, hd); + retVal___ = postHookFunc(retVal___, skill_id, hd); } } return retVal___; @@ -67430,11 +67788,11 @@ int HP_skill_not_ok_mercenary(uint16 skill_id, struct mercenary_data *md) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_not_ok_mercenary_pre ) { - int (*preHookFunc) (uint16 *skill_id, struct mercenary_data *md); + int (*preHookFunc) (uint16 *skill_id, struct mercenary_data **md); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_mercenary_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_not_ok_mercenary_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, md); + retVal___ = preHookFunc(&skill_id, &md); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67445,10 +67803,10 @@ int HP_skill_not_ok_mercenary(uint16 skill_id, struct mercenary_data *md) { retVal___ = HPMHooks.source.skill.not_ok_mercenary(skill_id, md); } if( HPMHooks.count.HP_skill_not_ok_mercenary_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, struct mercenary_data *md); + int (*postHookFunc) (int retVal___, uint16 skill_id, struct mercenary_data *md); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_mercenary_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_not_ok_mercenary_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, md); + retVal___ = postHookFunc(retVal___, skill_id, md); } } return retVal___; @@ -67457,12 +67815,12 @@ int HP_skill_chastle_mob_changetarget(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_chastle_mob_changetarget_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chastle_mob_changetarget_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_chastle_mob_changetarget_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67490,11 +67848,11 @@ int HP_skill_can_produce_mix(struct map_session_data *sd, int nameid, int trigge int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_can_produce_mix_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *trigger, int *qty); + int (*preHookFunc) (struct map_session_data **sd, int *nameid, int *trigger, int *qty); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_produce_mix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_can_produce_mix_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid, &trigger, &qty); + retVal___ = preHookFunc(&sd, &nameid, &trigger, &qty); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67505,10 +67863,10 @@ int HP_skill_can_produce_mix(struct map_session_data *sd, int nameid, int trigge retVal___ = HPMHooks.source.skill.can_produce_mix(sd, nameid, trigger, qty); } if( HPMHooks.count.HP_skill_can_produce_mix_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *trigger, int *qty); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int trigger, int qty); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_produce_mix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_can_produce_mix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid, &trigger, &qty); + retVal___ = postHookFunc(retVal___, sd, nameid, trigger, qty); } } return retVal___; @@ -67517,11 +67875,11 @@ int HP_skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int namei int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_produce_mix_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_produce_mix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_produce_mix_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &nameid, &slot1, &slot2, &slot3, &qty); + retVal___ = preHookFunc(&sd, &skill_id, &nameid, &slot1, &slot2, &slot3, &qty); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67532,10 +67890,10 @@ int HP_skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int namei retVal___ = HPMHooks.source.skill.produce_mix(sd, skill_id, nameid, slot1, slot2, slot3, qty); } if( HPMHooks.count.HP_skill_produce_mix_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_produce_mix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_produce_mix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &nameid, &slot1, &slot2, &slot3, &qty); + retVal___ = postHookFunc(retVal___, sd, skill_id, nameid, slot1, slot2, slot3, qty); } } return retVal___; @@ -67544,11 +67902,11 @@ int HP_skill_arrow_create(struct map_session_data *sd, int nameid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_arrow_create_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid); + int (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_arrow_create_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_arrow_create_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67559,10 +67917,10 @@ int HP_skill_arrow_create(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.skill.arrow_create(sd, nameid); } if( HPMHooks.count.HP_skill_arrow_create_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_arrow_create_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_arrow_create_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -67571,11 +67929,11 @@ int HP_skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_castend_nodamage_id_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67586,10 +67944,10 @@ int HP_skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, retVal___ = HPMHooks.source.skill.castend_nodamage_id(src, bl, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_castend_nodamage_id_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag); } } return retVal___; @@ -67598,11 +67956,11 @@ int HP_skill_castend_damage_id(struct block_list *src, struct block_list *bl, ui int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_castend_damage_id_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_damage_id_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67613,10 +67971,10 @@ int HP_skill_castend_damage_id(struct block_list *src, struct block_list *bl, ui retVal___ = HPMHooks.source.skill.castend_damage_id(src, bl, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_castend_damage_id_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_damage_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag); } } return retVal___; @@ -67625,11 +67983,11 @@ int HP_skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_castend_pos2_pre ) { - int (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (struct block_list **src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_pos2_pre[hIndex].func; - retVal___ = preHookFunc(src, &x, &y, &skill_id, &skill_lv, &tick, &flag); + retVal___ = preHookFunc(&src, &x, &y, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67640,10 +67998,10 @@ int HP_skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill_id, retVal___ = HPMHooks.source.skill.castend_pos2(src, x, y, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_castend_pos2_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, int x, int y, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_castend_pos2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &x, &y, &skill_id, &skill_lv, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, x, y, skill_id, skill_lv, tick, flag); } } return retVal___; @@ -67652,11 +68010,11 @@ int HP_skill_blockpc_start(struct map_session_data *sd, uint16 skill_id, int tic int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_blockpc_start_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *tick); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, int *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_blockpc_start_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id, &tick); + retVal___ = preHookFunc(&sd, &skill_id, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67667,10 +68025,10 @@ int HP_skill_blockpc_start(struct map_session_data *sd, uint16 skill_id, int tic retVal___ = HPMHooks.source.skill.blockpc_start(sd, skill_id, tick); } if( HPMHooks.count.HP_skill_blockpc_start_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, int *tick); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, int tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockpc_start_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id, &tick); + retVal___ = postHookFunc(retVal___, sd, skill_id, tick); } } return retVal___; @@ -67679,11 +68037,11 @@ int HP_skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_blockhomun_start_pre ) { - int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id, int *tick); + int (*preHookFunc) (struct homun_data **hd, uint16 *skill_id, int *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_blockhomun_start_pre[hIndex].func; - retVal___ = preHookFunc(hd, &skill_id, &tick); + retVal___ = preHookFunc(&hd, &skill_id, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67694,10 +68052,10 @@ int HP_skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick) retVal___ = HPMHooks.source.skill.blockhomun_start(hd, skill_id, tick); } if( HPMHooks.count.HP_skill_blockhomun_start_post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 *skill_id, int *tick); + int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 skill_id, int tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockhomun_start_post[hIndex].func; - retVal___ = postHookFunc(retVal___, hd, &skill_id, &tick); + retVal___ = postHookFunc(retVal___, hd, skill_id, tick); } } return retVal___; @@ -67706,11 +68064,11 @@ int HP_skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tic int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_blockmerc_start_pre ) { - int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id, int *tick); + int (*preHookFunc) (struct mercenary_data **md, uint16 *skill_id, int *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_blockmerc_start_pre[hIndex].func; - retVal___ = preHookFunc(md, &skill_id, &tick); + retVal___ = preHookFunc(&md, &skill_id, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67721,10 +68079,10 @@ int HP_skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tic retVal___ = HPMHooks.source.skill.blockmerc_start(md, skill_id, tick); } if( HPMHooks.count.HP_skill_blockmerc_start_post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 *skill_id, int *tick); + int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 skill_id, int tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockmerc_start_post[hIndex].func; - retVal___ = postHookFunc(retVal___, md, &skill_id, &tick); + retVal___ = postHookFunc(retVal___, md, skill_id, tick); } } return retVal___; @@ -67733,11 +68091,11 @@ int HP_skill_attack(int attack_type, struct block_list *src, struct block_list * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_attack_pre ) { - int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (int *attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_pre[hIndex].func; - retVal___ = preHookFunc(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67748,10 +68106,10 @@ int HP_skill_attack(int attack_type, struct block_list *src, struct block_list * retVal___ = HPMHooks.source.skill.attack(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_attack_post ) { - int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, int attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag); + retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag); } } return retVal___; @@ -67760,12 +68118,12 @@ int HP_skill_attack_area(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_attack_area_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_area_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_attack_area_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67793,12 +68151,12 @@ int HP_skill_area_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_area_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_area_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67826,11 +68184,11 @@ int HP_skill_area_sub_count(struct block_list *src, struct block_list *target, u int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_area_sub_count_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_count_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_area_sub_count_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &tick, &flag); + retVal___ = preHookFunc(&src, &target, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67841,10 +68199,10 @@ int HP_skill_area_sub_count(struct block_list *src, struct block_list *target, u retVal___ = HPMHooks.source.skill.area_sub_count(src, target, skill_id, skill_lv, tick, flag); } if( HPMHooks.count.HP_skill_area_sub_count_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_count_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_area_sub_count_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, tick, flag); } } return retVal___; @@ -67853,11 +68211,11 @@ int HP_skill_check_unit_range(struct block_list *bl, int x, int y, uint16 skill_ int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_unit_range_pre ) { - int (*preHookFunc) (struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_unit_range_pre[hIndex].func; - retVal___ = preHookFunc(bl, &x, &y, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &x, &y, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67868,10 +68226,10 @@ int HP_skill_check_unit_range(struct block_list *bl, int x, int y, uint16 skill_ retVal___ = HPMHooks.source.skill.check_unit_range(bl, x, y, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_check_unit_range_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_unit_range_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &x, &y, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, x, y, skill_id, skill_lv); } } return retVal___; @@ -67880,12 +68238,12 @@ int HP_skill_check_unit_range_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_unit_range_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_check_unit_range_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67913,11 +68271,11 @@ int HP_skill_check_unit_range2(struct block_list *bl, int x, int y, uint16 skill int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_unit_range2_pre ) { - int (*preHookFunc) (struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_unit_range2_pre[hIndex].func; - retVal___ = preHookFunc(bl, &x, &y, &skill_id, &skill_lv); + retVal___ = preHookFunc(&bl, &x, &y, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67928,10 +68286,10 @@ int HP_skill_check_unit_range2(struct block_list *bl, int x, int y, uint16 skill retVal___ = HPMHooks.source.skill.check_unit_range2(bl, x, y, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_check_unit_range2_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_unit_range2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &x, &y, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, bl, x, y, skill_id, skill_lv); } } return retVal___; @@ -67940,12 +68298,12 @@ int HP_skill_check_unit_range2_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_unit_range2_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_check_unit_range2_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -67972,11 +68330,11 @@ int HP_skill_check_unit_range2_sub(struct block_list *bl, va_list ap) { void HP_skill_toggle_magicpower(struct block_list *bl, uint16 skill_id) { int hIndex = 0; if( HPMHooks.count.HP_skill_toggle_magicpower_pre ) { - void (*preHookFunc) (struct block_list *bl, uint16 *skill_id); + void (*preHookFunc) (struct block_list **bl, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_toggle_magicpower_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_toggle_magicpower_pre[hIndex].func; - preHookFunc(bl, &skill_id); + preHookFunc(&bl, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -67987,10 +68345,10 @@ void HP_skill_toggle_magicpower(struct block_list *bl, uint16 skill_id) { HPMHooks.source.skill.toggle_magicpower(bl, skill_id); } if( HPMHooks.count.HP_skill_toggle_magicpower_post ) { - void (*postHookFunc) (struct block_list *bl, uint16 *skill_id); + void (*postHookFunc) (struct block_list *bl, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_toggle_magicpower_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_toggle_magicpower_post[hIndex].func; - postHookFunc(bl, &skill_id); + postHookFunc(bl, skill_id); } } return; @@ -67999,11 +68357,11 @@ int HP_skill_magic_reflect(struct block_list *src, struct block_list *bl, int ty int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_magic_reflect_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magic_reflect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_magic_reflect_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &type); + retVal___ = preHookFunc(&src, &bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68014,10 +68372,10 @@ int HP_skill_magic_reflect(struct block_list *src, struct block_list *bl, int ty retVal___ = HPMHooks.source.skill.magic_reflect(src, bl, type); } if( HPMHooks.count.HP_skill_magic_reflect_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magic_reflect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_magic_reflect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &type); + retVal___ = postHookFunc(retVal___, src, bl, type); } } return retVal___; @@ -68026,11 +68384,11 @@ int HP_skill_onskillusage(struct map_session_data *sd, struct block_list *bl, ui int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_onskillusage_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_id, int64 *tick); + int (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, uint16 *skill_id, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_onskillusage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_onskillusage_pre[hIndex].func; - retVal___ = preHookFunc(sd, bl, &skill_id, &tick); + retVal___ = preHookFunc(&sd, &bl, &skill_id, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68041,10 +68399,10 @@ int HP_skill_onskillusage(struct map_session_data *sd, struct block_list *bl, ui retVal___ = HPMHooks.source.skill.onskillusage(sd, bl, skill_id, tick); } if( HPMHooks.count.HP_skill_onskillusage_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 *skill_id, int64 *tick); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_onskillusage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_onskillusage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, bl, &skill_id, &tick); + retVal___ = postHookFunc(retVal___, sd, bl, skill_id, tick); } } return retVal___; @@ -68053,12 +68411,12 @@ int HP_skill_cell_overlap(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_cell_overlap_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cell_overlap_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_cell_overlap_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68101,10 +68459,10 @@ int HP_skill_timerskill(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.timerskill(tid, tick, id, data); } if( HPMHooks.count.HP_skill_timerskill_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_timerskill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -68113,12 +68471,12 @@ int HP_skill_trap_splash(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_trap_splash_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_splash_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_trap_splash_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68146,11 +68504,11 @@ int HP_skill_check_condition_mercenary(struct block_list *bl, int skill_id, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_mercenary_pre ) { - int (*preHookFunc) (struct block_list *bl, int *skill_id, int *lv, int *type); + int (*preHookFunc) (struct block_list **bl, int *skill_id, int *lv, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mercenary_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_mercenary_pre[hIndex].func; - retVal___ = preHookFunc(bl, &skill_id, &lv, &type); + retVal___ = preHookFunc(&bl, &skill_id, &lv, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68161,10 +68519,10 @@ int HP_skill_check_condition_mercenary(struct block_list *bl, int skill_id, int retVal___ = HPMHooks.source.skill.check_condition_mercenary(bl, skill_id, lv, type); } if( HPMHooks.count.HP_skill_check_condition_mercenary_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *skill_id, int *lv, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int skill_id, int lv, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mercenary_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_condition_mercenary_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &skill_id, &lv, &type); + retVal___ = postHookFunc(retVal___, bl, skill_id, lv, type); } } return retVal___; @@ -68173,11 +68531,11 @@ struct skill_unit_group* HP_skill_locate_element_field(struct block_list *bl) { int hIndex = 0; struct skill_unit_group* retVal___ = NULL; if( HPMHooks.count.HP_skill_locate_element_field_pre ) { - struct skill_unit_group* (*preHookFunc) (struct block_list *bl); + struct skill_unit_group* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_locate_element_field_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_locate_element_field_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68200,12 +68558,12 @@ int HP_skill_graffitiremover(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_graffitiremover_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_graffitiremover_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_graffitiremover_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68233,12 +68591,12 @@ int HP_skill_activate_reverberation(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_activate_reverberation_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_activate_reverberation_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_activate_reverberation_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68266,12 +68624,12 @@ int HP_skill_dance_overlap_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_dance_overlap_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_dance_overlap_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68299,11 +68657,11 @@ int HP_skill_dance_overlap(struct skill_unit *su, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_dance_overlap_pre ) { - int (*preHookFunc) (struct skill_unit *su, int *flag); + int (*preHookFunc) (struct skill_unit **su, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_dance_overlap_pre[hIndex].func; - retVal___ = preHookFunc(su, &flag); + retVal___ = preHookFunc(&su, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68314,10 +68672,10 @@ int HP_skill_dance_overlap(struct skill_unit *su, int flag) { retVal___ = HPMHooks.source.skill.dance_overlap(su, flag); } if( HPMHooks.count.HP_skill_dance_overlap_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit *su, int *flag); + int (*postHookFunc) (int retVal___, struct skill_unit *su, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_dance_overlap_post[hIndex].func; - retVal___ = postHookFunc(retVal___, su, &flag); + retVal___ = postHookFunc(retVal___, su, flag); } } return retVal___; @@ -68326,11 +68684,11 @@ struct s_skill_unit_layout* HP_skill_get_unit_layout(uint16 skill_id, uint16 ski int hIndex = 0; struct s_skill_unit_layout* retVal___ = NULL; if( HPMHooks.count.HP_skill_get_unit_layout_pre ) { - struct s_skill_unit_layout* (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv, struct block_list *src, int *x, int *y); + struct s_skill_unit_layout* (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv, struct block_list **src, int *x, int *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_unit_layout_pre[hIndex].func; - retVal___ = preHookFunc(&skill_id, &skill_lv, src, &x, &y); + retVal___ = preHookFunc(&skill_id, &skill_lv, &src, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68341,10 +68699,10 @@ struct s_skill_unit_layout* HP_skill_get_unit_layout(uint16 skill_id, uint16 ski retVal___ = HPMHooks.source.skill.get_unit_layout(skill_id, skill_lv, src, x, y); } if( HPMHooks.count.HP_skill_get_unit_layout_post ) { - struct s_skill_unit_layout* (*postHookFunc) (struct s_skill_unit_layout* retVal___, uint16 *skill_id, uint16 *skill_lv, struct block_list *src, int *x, int *y); + struct s_skill_unit_layout* (*postHookFunc) (struct s_skill_unit_layout* retVal___, uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv, src, &x, &y); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv, src, x, y); } } return retVal___; @@ -68353,12 +68711,12 @@ int HP_skill_frostjoke_scream(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_frostjoke_scream_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_frostjoke_scream_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_frostjoke_scream_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68386,12 +68744,12 @@ int HP_skill_greed(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_greed_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_greed_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_greed_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68419,12 +68777,12 @@ int HP_skill_destroy_trap(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_destroy_trap_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_destroy_trap_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_destroy_trap_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68452,11 +68810,11 @@ struct skill_unit_group_tickset* HP_skill_unitgrouptickset_search(struct block_l int hIndex = 0; struct skill_unit_group_tickset* retVal___ = NULL; if( HPMHooks.count.HP_skill_unitgrouptickset_search_pre ) { - struct skill_unit_group_tickset* (*preHookFunc) (struct block_list *bl, struct skill_unit_group *group, int64 *tick); + struct skill_unit_group_tickset* (*preHookFunc) (struct block_list **bl, struct skill_unit_group **group, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitgrouptickset_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unitgrouptickset_search_pre[hIndex].func; - retVal___ = preHookFunc(bl, group, &tick); + retVal___ = preHookFunc(&bl, &group, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68467,10 +68825,10 @@ struct skill_unit_group_tickset* HP_skill_unitgrouptickset_search(struct block_l retVal___ = HPMHooks.source.skill.unitgrouptickset_search(bl, group, tick); } if( HPMHooks.count.HP_skill_unitgrouptickset_search_post ) { - struct skill_unit_group_tickset* (*postHookFunc) (struct skill_unit_group_tickset* retVal___, struct block_list *bl, struct skill_unit_group *group, int64 *tick); + struct skill_unit_group_tickset* (*postHookFunc) (struct skill_unit_group_tickset* retVal___, struct block_list *bl, struct skill_unit_group *group, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitgrouptickset_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unitgrouptickset_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, group, &tick); + retVal___ = postHookFunc(retVal___, bl, group, tick); } } return retVal___; @@ -68479,11 +68837,11 @@ bool HP_skill_dance_switch(struct skill_unit *su, int flag) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_dance_switch_pre ) { - bool (*preHookFunc) (struct skill_unit *su, int *flag); + bool (*preHookFunc) (struct skill_unit **su, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_switch_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_dance_switch_pre[hIndex].func; - retVal___ = preHookFunc(su, &flag); + retVal___ = preHookFunc(&su, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68494,10 +68852,10 @@ bool HP_skill_dance_switch(struct skill_unit *su, int flag) { retVal___ = HPMHooks.source.skill.dance_switch(su, flag); } if( HPMHooks.count.HP_skill_dance_switch_post ) { - bool (*postHookFunc) (bool retVal___, struct skill_unit *su, int *flag); + bool (*postHookFunc) (bool retVal___, struct skill_unit *su, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_switch_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_dance_switch_post[hIndex].func; - retVal___ = postHookFunc(retVal___, su, &flag); + retVal___ = postHookFunc(retVal___, su, flag); } } return retVal___; @@ -68506,12 +68864,12 @@ int HP_skill_check_condition_char_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_char_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_char_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_check_condition_char_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68539,12 +68897,12 @@ int HP_skill_check_condition_mob_master_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_mob_master_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mob_master_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_check_condition_mob_master_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68571,11 +68929,11 @@ int HP_skill_check_condition_mob_master_sub(struct block_list *bl, va_list ap) { void HP_skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y) { int hIndex = 0; if( HPMHooks.count.HP_skill_brandishspear_first_pre ) { - void (*preHookFunc) (struct square *tc, uint8 *dir, int16 *x, int16 *y); + void (*preHookFunc) (struct square **tc, uint8 *dir, int16 *x, int16 *y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_first_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_brandishspear_first_pre[hIndex].func; - preHookFunc(tc, &dir, &x, &y); + preHookFunc(&tc, &dir, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68586,10 +68944,10 @@ void HP_skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y HPMHooks.source.skill.brandishspear_first(tc, dir, x, y); } if( HPMHooks.count.HP_skill_brandishspear_first_post ) { - void (*postHookFunc) (struct square *tc, uint8 *dir, int16 *x, int16 *y); + void (*postHookFunc) (struct square *tc, uint8 dir, int16 x, int16 y); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_first_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_brandishspear_first_post[hIndex].func; - postHookFunc(tc, &dir, &x, &y); + postHookFunc(tc, dir, x, y); } } return; @@ -68597,11 +68955,11 @@ void HP_skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y void HP_skill_brandishspear_dir(struct square *tc, uint8 dir, int are) { int hIndex = 0; if( HPMHooks.count.HP_skill_brandishspear_dir_pre ) { - void (*preHookFunc) (struct square *tc, uint8 *dir, int *are); + void (*preHookFunc) (struct square **tc, uint8 *dir, int *are); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_dir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_brandishspear_dir_pre[hIndex].func; - preHookFunc(tc, &dir, &are); + preHookFunc(&tc, &dir, &are); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68612,10 +68970,10 @@ void HP_skill_brandishspear_dir(struct square *tc, uint8 dir, int are) { HPMHooks.source.skill.brandishspear_dir(tc, dir, are); } if( HPMHooks.count.HP_skill_brandishspear_dir_post ) { - void (*postHookFunc) (struct square *tc, uint8 *dir, int *are); + void (*postHookFunc) (struct square *tc, uint8 dir, int are); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_dir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_brandishspear_dir_post[hIndex].func; - postHookFunc(tc, &dir, &are); + postHookFunc(tc, dir, are); } } return; @@ -68639,10 +68997,10 @@ int HP_skill_get_fixed_cast(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_fixed_cast(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_fixed_cast_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_fixed_cast_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_fixed_cast_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -68651,12 +69009,12 @@ int HP_skill_sit_count(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_sit_count_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_count_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_sit_count_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68684,12 +69042,12 @@ int HP_skill_sit_in(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_sit_in_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_in_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_sit_in_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68717,12 +69075,12 @@ int HP_skill_sit_out(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_sit_out_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_out_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_sit_out_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68749,11 +69107,11 @@ int HP_skill_sit_out(struct block_list *bl, va_list ap) { void HP_skill_unitsetmapcell(struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag) { int hIndex = 0; if( HPMHooks.count.HP_skill_unitsetmapcell_pre ) { - void (*preHookFunc) (struct skill_unit *src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag); + void (*preHookFunc) (struct skill_unit **src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetmapcell_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unitsetmapcell_pre[hIndex].func; - preHookFunc(src, &skill_id, &skill_lv, &cell, &flag); + preHookFunc(&src, &skill_id, &skill_lv, &cell, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68764,10 +69122,10 @@ void HP_skill_unitsetmapcell(struct skill_unit *src, uint16 skill_id, uint16 ski HPMHooks.source.skill.unitsetmapcell(src, skill_id, skill_lv, cell, flag); } if( HPMHooks.count.HP_skill_unitsetmapcell_post ) { - void (*postHookFunc) (struct skill_unit *src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag); + void (*postHookFunc) (struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetmapcell_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unitsetmapcell_post[hIndex].func; - postHookFunc(src, &skill_id, &skill_lv, &cell, &flag); + postHookFunc(src, skill_id, skill_lv, cell, flag); } } return; @@ -68776,11 +69134,11 @@ int HP_skill_unit_onplace_timer(struct skill_unit *src, struct block_list *bl, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_onplace_timer_pre ) { - int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &tick); + retVal___ = preHookFunc(&src, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -68791,10 +69149,10 @@ int HP_skill_unit_onplace_timer(struct skill_unit *src, struct block_list *bl, i retVal___ = HPMHooks.source.skill.unit_onplace_timer(src, bl, tick); } if( HPMHooks.count.HP_skill_unit_onplace_timer_post ) { - int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 *tick); + int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &tick); + retVal___ = postHookFunc(retVal___, src, bl, tick); } } return retVal___; @@ -68803,12 +69161,12 @@ int HP_skill_unit_effect(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_effect_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_effect_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_unit_effect_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68836,12 +69194,12 @@ int HP_skill_unit_timer_sub_onplace(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_timer_sub_onplace_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_onplace_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_onplace_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68869,12 +69227,12 @@ int HP_skill_unit_move_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_move_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_unit_move_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -68917,10 +69275,10 @@ int HP_skill_blockpc_end(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.blockpc_end(tid, tick, id, data); } if( HPMHooks.count.HP_skill_blockpc_end_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockpc_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -68944,10 +69302,10 @@ int HP_skill_blockhomun_end(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.blockhomun_end(tid, tick, id, data); } if( HPMHooks.count.HP_skill_blockhomun_end_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockhomun_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -68971,10 +69329,10 @@ int HP_skill_blockmerc_end(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.blockmerc_end(tid, tick, id, data); } if( HPMHooks.count.HP_skill_blockmerc_end_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_end_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_blockmerc_end_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -68983,11 +69341,11 @@ int HP_skill_split_atoi(char *str, int *val) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_split_atoi_pre ) { - int (*preHookFunc) (char *str, int *val); + int (*preHookFunc) (char **str, int **val); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_split_atoi_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_split_atoi_pre[hIndex].func; - retVal___ = preHookFunc(str, val); + retVal___ = preHookFunc(&str, &val); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69025,10 +69383,10 @@ int HP_skill_unit_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.skill.unit_timer(tid, tick, id, data); } if( HPMHooks.count.HP_skill_unit_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_unit_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -69037,12 +69395,12 @@ int HP_skill_unit_timer_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_unit_timer_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -69056,11 +69414,11 @@ int HP_skill_unit_timer_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_skill_unit_timer_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -69096,11 +69454,11 @@ bool HP_skill_parse_row_skilldb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_skilldb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_skilldb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_skilldb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69111,10 +69469,10 @@ bool HP_skill_parse_row_skilldb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_skilldb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_skilldb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_skilldb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_skilldb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69123,11 +69481,11 @@ bool HP_skill_parse_row_requiredb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_requiredb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_requiredb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_requiredb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69138,10 +69496,10 @@ bool HP_skill_parse_row_requiredb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_requiredb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_requiredb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_requiredb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_requiredb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69150,11 +69508,11 @@ bool HP_skill_parse_row_castdb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_castdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_castdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69165,10 +69523,10 @@ bool HP_skill_parse_row_castdb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_castdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_castdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_castdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69177,11 +69535,11 @@ bool HP_skill_parse_row_castnodexdb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_castnodexdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castnodexdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_castnodexdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69192,10 +69550,10 @@ bool HP_skill_parse_row_castnodexdb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_castnodexdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_castnodexdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castnodexdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_castnodexdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69204,11 +69562,11 @@ bool HP_skill_parse_row_unitdb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_unitdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_unitdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_unitdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69219,10 +69577,10 @@ bool HP_skill_parse_row_unitdb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_unitdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_unitdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_unitdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_unitdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69231,11 +69589,11 @@ bool HP_skill_parse_row_producedb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_producedb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_producedb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_producedb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69246,10 +69604,10 @@ bool HP_skill_parse_row_producedb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_producedb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_producedb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_producedb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_producedb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69258,11 +69616,11 @@ bool HP_skill_parse_row_createarrowdb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_createarrowdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_createarrowdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_createarrowdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69273,10 +69631,10 @@ bool HP_skill_parse_row_createarrowdb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_createarrowdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_createarrowdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_createarrowdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_createarrowdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69285,11 +69643,11 @@ bool HP_skill_parse_row_abradb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_abradb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_abradb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_abradb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69300,10 +69658,10 @@ bool HP_skill_parse_row_abradb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_abradb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_abradb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_abradb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_abradb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69312,11 +69670,11 @@ bool HP_skill_parse_row_spellbookdb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_spellbookdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_spellbookdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_spellbookdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69327,10 +69685,10 @@ bool HP_skill_parse_row_spellbookdb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_spellbookdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_spellbookdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_spellbookdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_spellbookdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69339,11 +69697,11 @@ bool HP_skill_parse_row_magicmushroomdb(char *split[], int column, int current) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_pre ) { - bool (*preHookFunc) (char *split[], int *column, int *current); + bool (*preHookFunc) (char **split[], int *column, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_magicmushroomdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_magicmushroomdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &column, ¤t); + retVal___ = preHookFunc(&split, &column, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69354,10 +69712,10 @@ bool HP_skill_parse_row_magicmushroomdb(char *split[], int column, int current) retVal___ = HPMHooks.source.skill.parse_row_magicmushroomdb(split, column, current); } if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *column, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int column, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_magicmushroomdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &column, ¤t); + retVal___ = postHookFunc(retVal___, split, column, current); } } return retVal___; @@ -69366,11 +69724,11 @@ bool HP_skill_parse_row_reproducedb(char *split[], int column, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_reproducedb_pre ) { - bool (*preHookFunc) (char *split[], int *column, int *current); + bool (*preHookFunc) (char **split[], int *column, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_reproducedb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_reproducedb_pre[hIndex].func; - retVal___ = preHookFunc(split, &column, ¤t); + retVal___ = preHookFunc(&split, &column, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69381,10 +69739,10 @@ bool HP_skill_parse_row_reproducedb(char *split[], int column, int current) { retVal___ = HPMHooks.source.skill.parse_row_reproducedb(split, column, current); } if( HPMHooks.count.HP_skill_parse_row_reproducedb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *column, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int column, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_reproducedb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_reproducedb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &column, ¤t); + retVal___ = postHookFunc(retVal___, split, column, current); } } return retVal___; @@ -69393,11 +69751,11 @@ bool HP_skill_parse_row_improvisedb(char *split[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_improvisedb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_improvisedb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_improvisedb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69408,10 +69766,10 @@ bool HP_skill_parse_row_improvisedb(char *split[], int columns, int current) { retVal___ = HPMHooks.source.skill.parse_row_improvisedb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_improvisedb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_improvisedb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_improvisedb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69420,11 +69778,11 @@ bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_parse_row_changematerialdb_pre ) { - bool (*preHookFunc) (char *split[], int *columns, int *current); + bool (*preHookFunc) (char **split[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_changematerialdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_parse_row_changematerialdb_pre[hIndex].func; - retVal___ = preHookFunc(split, &columns, ¤t); + retVal___ = preHookFunc(&split, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69435,10 +69793,10 @@ bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current retVal___ = HPMHooks.source.skill.parse_row_changematerialdb(split, columns, current); } if( HPMHooks.count.HP_skill_parse_row_changematerialdb_post ) { - bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_changematerialdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_parse_row_changematerialdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, split, &columns, ¤t); + retVal___ = postHookFunc(retVal___, split, columns, current); } } return retVal___; @@ -69446,11 +69804,11 @@ bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_skill_usave_add_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_usave_add_pre[hIndex].func; - preHookFunc(sd, &skill_id, &skill_lv); + preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69461,10 +69819,10 @@ void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 ski HPMHooks.source.skill.usave_add(sd, skill_id, skill_lv); } if( HPMHooks.count.HP_skill_usave_add_post ) { - void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_usave_add_post[hIndex].func; - postHookFunc(sd, &skill_id, &skill_lv); + postHookFunc(sd, skill_id, skill_lv); } } return; @@ -69472,11 +69830,11 @@ void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 ski void HP_skill_usave_trigger(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_skill_usave_trigger_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_trigger_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_usave_trigger_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69498,11 +69856,11 @@ void HP_skill_usave_trigger(struct map_session_data *sd) { void HP_skill_cooldown_load(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_skill_cooldown_load_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_load_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_cooldown_load_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69525,11 +69883,11 @@ int HP_skill_spellbook(struct map_session_data *sd, int nameid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_spellbook_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid); + int (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_spellbook_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69540,10 +69898,10 @@ int HP_skill_spellbook(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.skill.spellbook(sd, nameid); } if( HPMHooks.count.HP_skill_spellbook_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_spellbook_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -69552,11 +69910,11 @@ int HP_skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_ int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_block_check_pre ) { - int (*preHookFunc) (struct block_list *bl, enum sc_type *type, uint16 *skill_id); + int (*preHookFunc) (struct block_list **bl, enum sc_type *type, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_block_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_block_check_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type, &skill_id); + retVal___ = preHookFunc(&bl, &type, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69567,10 +69925,10 @@ int HP_skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_ retVal___ = HPMHooks.source.skill.block_check(bl, type, skill_id); } if( HPMHooks.count.HP_skill_block_check_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type type, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_block_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_block_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type, &skill_id); + retVal___ = postHookFunc(retVal___, bl, type, skill_id); } } return retVal___; @@ -69579,12 +69937,12 @@ int HP_skill_detonator(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_detonator_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_detonator_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_skill_detonator_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -69612,11 +69970,11 @@ bool HP_skill_check_camouflage(struct block_list *bl, struct status_change_entry int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_check_camouflage_pre ) { - bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce); + bool (*preHookFunc) (struct block_list **bl, struct status_change_entry **sce); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_camouflage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_camouflage_pre[hIndex].func; - retVal___ = preHookFunc(bl, sce); + retVal___ = preHookFunc(&bl, &sce); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69639,11 +69997,11 @@ int HP_skill_magicdecoy(struct map_session_data *sd, int nameid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_magicdecoy_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid); + int (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_magicdecoy_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69654,10 +70012,10 @@ int HP_skill_magicdecoy(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.skill.magicdecoy(sd, nameid); } if( HPMHooks.count.HP_skill_magicdecoy_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_magicdecoy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -69666,11 +70024,11 @@ int HP_skill_poisoningweapon(struct map_session_data *sd, int nameid) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_poisoningweapon_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *nameid); + int (*preHookFunc) (struct map_session_data **sd, int *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_poisoningweapon_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69681,10 +70039,10 @@ int HP_skill_poisoningweapon(struct map_session_data *sd, int nameid) { retVal___ = HPMHooks.source.skill.poisoningweapon(sd, nameid); } if( HPMHooks.count.HP_skill_poisoningweapon_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_poisoningweapon_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -69693,11 +70051,11 @@ int HP_skill_select_menu(struct map_session_data *sd, uint16 skill_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_select_menu_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_select_menu_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_select_menu_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_id); + retVal___ = preHookFunc(&sd, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69708,10 +70066,10 @@ int HP_skill_select_menu(struct map_session_data *sd, uint16 skill_id) { retVal___ = HPMHooks.source.skill.select_menu(sd, skill_id); } if( HPMHooks.count.HP_skill_select_menu_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_select_menu_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_select_menu_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_id); + retVal___ = postHookFunc(retVal___, sd, skill_id); } } return retVal___; @@ -69720,11 +70078,11 @@ int HP_skill_elementalanalysis(struct map_session_data *sd, uint16 skill_lv, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_elementalanalysis_pre ) { - int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv, const struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv, const struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_elementalanalysis_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_elementalanalysis_pre[hIndex].func; - retVal___ = preHookFunc(sd, &skill_lv, item_list); + retVal___ = preHookFunc(&sd, &skill_lv, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69735,10 +70093,10 @@ int HP_skill_elementalanalysis(struct map_session_data *sd, uint16 skill_lv, con retVal___ = HPMHooks.source.skill.elementalanalysis(sd, skill_lv, item_list); } if( HPMHooks.count.HP_skill_elementalanalysis_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv, const struct itemlist *item_list); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv, const struct itemlist *item_list); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_elementalanalysis_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_elementalanalysis_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &skill_lv, item_list); + retVal___ = postHookFunc(retVal___, sd, skill_lv, item_list); } } return retVal___; @@ -69747,11 +70105,11 @@ int HP_skill_changematerial(struct map_session_data *sd, const struct itemlist * int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_changematerial_pre ) { - int (*preHookFunc) (struct map_session_data *sd, const struct itemlist *item_list); + int (*preHookFunc) (struct map_session_data **sd, const struct itemlist **item_list); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_changematerial_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_changematerial_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_list); + retVal___ = preHookFunc(&sd, &item_list); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69789,10 +70147,10 @@ int HP_skill_get_elemental_type(uint16 skill_id, uint16 skill_lv) { retVal___ = HPMHooks.source.skill.get_elemental_type(skill_id, skill_lv); } if( HPMHooks.count.HP_skill_get_elemental_type_post ) { - int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_elemental_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_get_elemental_type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, skill_id, skill_lv); } } return retVal___; @@ -69800,11 +70158,11 @@ int HP_skill_get_elemental_type(uint16 skill_id, uint16 skill_lv) { void HP_skill_cooldown_save(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_skill_cooldown_save_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_save_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_cooldown_save_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69854,11 +70212,11 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_check_shadowform_pre ) { - bool (*preHookFunc) (struct block_list *bl, int64 *damage, int *hit); + bool (*preHookFunc) (struct block_list **bl, int64 *damage, int *hit); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_shadowform_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_shadowform_pre[hIndex].func; - retVal___ = preHookFunc(bl, &damage, &hit); + retVal___ = preHookFunc(&bl, &damage, &hit); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69869,10 +70227,10 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) { retVal___ = HPMHooks.source.skill.check_shadowform(bl, damage, hit); } if( HPMHooks.count.HP_skill_check_shadowform_post ) { - bool (*postHookFunc) (bool retVal___, struct block_list *bl, int64 *damage, int *hit); + bool (*postHookFunc) (bool retVal___, struct block_list *bl, int64 damage, int hit); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_shadowform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_check_shadowform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &damage, &hit); + retVal___ = postHookFunc(retVal___, bl, damage, hit); } } return retVal___; @@ -69881,11 +70239,11 @@ bool HP_skill_castend_damage_id_unknown(struct block_list *src, struct block_lis int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_damage_id_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, struct status_data **tstatus, struct status_change **sc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_damage_id_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag, tstatus, sc); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag, &tstatus, &sc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69907,11 +70265,11 @@ bool HP_skill_castend_damage_id_unknown(struct block_list *src, struct block_lis void HP_skill_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick) { int hIndex = 0; if( HPMHooks.count.HP_skill_additional_effect_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick); + void (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int **attack_type, int **dmg_lv, int64 **tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_additional_effect_unknown_pre[hIndex].func; - preHookFunc(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick); + preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69933,11 +70291,11 @@ void HP_skill_additional_effect_unknown(struct block_list *src, struct block_lis void HP_skill_counter_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick) { int hIndex = 0; if( HPMHooks.count.HP_skill_counter_additional_effect_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick); + void (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int **attack_type, int64 **tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_unknown_pre[hIndex].func; - preHookFunc(src, bl, skill_id, skill_lv, attack_type, tick); + preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69959,11 +70317,11 @@ void HP_skill_counter_additional_effect_unknown(struct block_list *src, struct b void HP_skill_attack_combo1_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo) { int hIndex = 0; if( HPMHooks.count.HP_skill_attack_combo1_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_change_entry *sce, int *combo); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, struct status_change_entry **sce, int **combo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo1_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_combo1_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo); + preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &sce, &combo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -69985,11 +70343,11 @@ void HP_skill_attack_combo1_unknown(int *attack_type, struct block_list *src, st void HP_skill_attack_combo2_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo) { int hIndex = 0; if( HPMHooks.count.HP_skill_attack_combo2_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *combo); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **combo); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo2_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_combo2_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo); + preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &combo); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70011,11 +70369,11 @@ void HP_skill_attack_combo2_unknown(int *attack_type, struct block_list *src, st void HP_skill_attack_display_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage) { int hIndex = 0; if( HPMHooks.count.HP_skill_attack_display_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **type, struct Damage **dmg, int64 **damage); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_display_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_display_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage); + preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70038,11 +70396,11 @@ int HP_skill_attack_copy_unknown(int *attack_type, struct block_list *src, struc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_attack_copy_unknown_pre ) { - int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_copy_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_copy_unknown_pre[hIndex].func; - retVal___ = preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70065,11 +70423,11 @@ int HP_skill_attack_dir_unknown(int *attack_type, struct block_list *src, struct int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_attack_dir_unknown_pre ) { - int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + int (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_dir_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_dir_unknown_pre[hIndex].func; - retVal___ = preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70091,11 +70449,11 @@ int HP_skill_attack_dir_unknown(int *attack_type, struct block_list *src, struct void HP_skill_attack_blow_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir) { int hIndex = 0; if( HPMHooks.count.HP_skill_attack_blow_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, int *type, struct Damage *dmg, int64 *damage, int8 *dir); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, int **type, struct Damage **dmg, int64 **damage, int8 **dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_blow_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_blow_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir); + preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage, &dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70117,11 +70475,11 @@ void HP_skill_attack_blow_unknown(int *attack_type, struct block_list *src, stru void HP_skill_attack_post_unknown(int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { int hIndex = 0; if( HPMHooks.count.HP_skill_attack_post_unknown_pre ) { - void (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + void (*preHookFunc) (int **attack_type, struct block_list **src, struct block_list **dsrc, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_attack_post_unknown_pre[hIndex].func; - preHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag); + preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70144,11 +70502,11 @@ bool HP_skill_timerskill_dead_unknown(struct block_list *src, struct unit_data * int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_timerskill_dead_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); + bool (*preHookFunc) (struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_dead_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_timerskill_dead_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, ud, skl); + retVal___ = preHookFunc(&src, &ud, &skl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70170,11 +70528,11 @@ bool HP_skill_timerskill_dead_unknown(struct block_list *src, struct unit_data * void HP_skill_timerskill_target_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl) { int hIndex = 0; if( HPMHooks.count.HP_skill_timerskill_target_unknown_pre ) { - void (*preHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl); + void (*preHookFunc) (int *tid, int64 *tick, struct block_list **src, struct block_list **target, struct unit_data **ud, struct skill_timerskill **skl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_pre[hIndex].func; - preHookFunc(&tid, &tick, src, target, ud, skl); + preHookFunc(&tid, &tick, &src, &target, &ud, &skl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70185,10 +70543,10 @@ void HP_skill_timerskill_target_unknown(int tid, int64 tick, struct block_list * HPMHooks.source.skill.timerskill_target_unknown(tid, tick, src, target, ud, skl); } if( HPMHooks.count.HP_skill_timerskill_target_unknown_post ) { - void (*postHookFunc) (int *tid, int64 *tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl); + void (*postHookFunc) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_post[hIndex].func; - postHookFunc(&tid, &tick, src, target, ud, skl); + postHookFunc(tid, tick, src, target, ud, skl); } } return; @@ -70196,11 +70554,11 @@ void HP_skill_timerskill_target_unknown(int tid, int64 tick, struct block_list * void HP_skill_timerskill_notarget_unknown(int tid, int64 tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl) { int hIndex = 0; if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre ) { - void (*preHookFunc) (int *tid, int64 *tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); + void (*preHookFunc) (int *tid, int64 *tick, struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_pre[hIndex].func; - preHookFunc(&tid, &tick, src, ud, skl); + preHookFunc(&tid, &tick, &src, &ud, &skl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70211,10 +70569,10 @@ void HP_skill_timerskill_notarget_unknown(int tid, int64 tick, struct block_list HPMHooks.source.skill.timerskill_notarget_unknown(tid, tick, src, ud, skl); } if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_post ) { - void (*postHookFunc) (int *tid, int64 *tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); + void (*postHookFunc) (int tid, int64 tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_post[hIndex].func; - postHookFunc(&tid, &tick, src, ud, skl); + postHookFunc(tid, tick, src, ud, skl); } } return; @@ -70238,10 +70596,10 @@ bool HP_skill_cleartimerskill_exception(int skill_id) { retVal___ = HPMHooks.source.skill.cleartimerskill_exception(skill_id); } if( HPMHooks.count.HP_skill_cleartimerskill_exception_post ) { - bool (*postHookFunc) (bool retVal___, int *skill_id); + bool (*postHookFunc) (bool retVal___, int skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_exception_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_exception_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -70250,11 +70608,11 @@ bool HP_skill_castend_id_unknown(struct unit_data *ud, struct block_list *src, s int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_id_unknown_pre ) { - bool (*preHookFunc) (struct unit_data *ud, struct block_list *src, struct block_list *target); + bool (*preHookFunc) (struct unit_data **ud, struct block_list **src, struct block_list **target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_id_unknown_pre[hIndex].func; - retVal___ = preHookFunc(ud, src, target); + retVal___ = preHookFunc(&ud, &src, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70277,11 +70635,11 @@ bool HP_skill_castend_nodamage_id_dead_unknown(struct block_list *src, struct bl int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_dead_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70304,11 +70662,11 @@ bool HP_skill_castend_nodamage_id_undead_unknown(struct block_list *src, struct int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_undead_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70331,11 +70689,11 @@ bool HP_skill_castend_nodamage_id_mado_unknown(struct block_list *src, struct bl int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_mado_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70358,11 +70716,11 @@ bool HP_skill_castend_nodamage_id_unknown(struct block_list *src, struct block_l int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_nodamage_id_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70384,11 +70742,11 @@ bool HP_skill_castend_nodamage_id_unknown(struct block_list *src, struct block_l void HP_skill_castend_pos2_effect_unknown(struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) { int hIndex = 0; if( HPMHooks.count.HP_skill_castend_pos2_effect_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + void (*preHookFunc) (struct block_list **src, int **x, int **y, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_effect_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_pos2_effect_unknown_pre[hIndex].func; - preHookFunc(src, x, y, skill_id, skill_lv, tick, flag); + preHookFunc(&src, &x, &y, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70411,11 +70769,11 @@ bool HP_skill_castend_pos2_unknown(struct block_list *src, int *x, int *y, uint1 int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_castend_pos2_unknown_pre ) { - bool (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag); + bool (*preHookFunc) (struct block_list **src, int **x, int **y, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_castend_pos2_unknown_pre[hIndex].func; - retVal___ = preHookFunc(src, x, y, skill_id, skill_lv, tick, flag); + retVal___ = preHookFunc(&src, &x, &y, &skill_id, &skill_lv, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70437,11 +70795,11 @@ bool HP_skill_castend_pos2_unknown(struct block_list *src, int *x, int *y, uint1 void HP_skill_unitsetting1_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3) { int hIndex = 0; if( HPMHooks.count.HP_skill_unitsetting1_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3); + void (*preHookFunc) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **val1, int **val2, int **val3); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting1_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unitsetting1_unknown_pre[hIndex].func; - preHookFunc(src, skill_id, skill_lv, x, y, flag, val1, val2, val3); + preHookFunc(&src, &skill_id, &skill_lv, &x, &y, &flag, &val1, &val2, &val3); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70463,11 +70821,11 @@ void HP_skill_unitsetting1_unknown(struct block_list *src, uint16 *skill_id, uin void HP_skill_unitsetting2_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group) { int hIndex = 0; if( HPMHooks.count.HP_skill_unitsetting2_unknown_pre ) { - void (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group); + void (*preHookFunc) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **unit_flag, int **val1, int **val2, int **val3, struct skill_unit_group **group); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting2_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unitsetting2_unknown_pre[hIndex].func; - preHookFunc(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group); + preHookFunc(&src, &skill_id, &skill_lv, &x, &y, &flag, &unit_flag, &val1, &val2, &val3, &group); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70489,11 +70847,11 @@ void HP_skill_unitsetting2_unknown(struct block_list *src, uint16 *skill_id, uin void HP_skill_unit_onplace_unknown(struct skill_unit *src, struct block_list *bl, int64 *tick) { int hIndex = 0; if( HPMHooks.count.HP_skill_unit_onplace_unknown_pre ) { - void (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick); + void (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 **tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_unit_onplace_unknown_pre[hIndex].func; - preHookFunc(src, bl, tick); + preHookFunc(&src, &bl, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70516,11 +70874,11 @@ int HP_skill_check_condition_castbegin_off_unknown(struct status_change *sc, uin int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre ) { - int (*preHookFunc) (struct status_change *sc, uint16 *skill_id); + int (*preHookFunc) (struct status_change **sc, uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_off_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, skill_id); + retVal___ = preHookFunc(&sc, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70543,11 +70901,11 @@ int HP_skill_check_condition_castbegin_mount_unknown(struct status_change *sc, u int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre ) { - int (*preHookFunc) (struct status_change *sc, uint16 *skill_id); + int (*preHookFunc) (struct status_change **sc, uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_mount_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, skill_id); + retVal___ = preHookFunc(&sc, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70570,11 +70928,11 @@ int HP_skill_check_condition_castbegin_madogear_unknown(struct status_change *sc int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre ) { - int (*preHookFunc) (struct status_change *sc, uint16 *skill_id); + int (*preHookFunc) (struct status_change **sc, uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_madogear_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, skill_id); + retVal___ = preHookFunc(&sc, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70597,11 +70955,11 @@ int HP_skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre ) { - int (*preHookFunc) (struct status_change *sc, uint16 *skill_id); + int (*preHookFunc) (struct status_change **sc, uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, skill_id); + retVal___ = preHookFunc(&sc, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70623,11 +70981,11 @@ int HP_skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 void HP_skill_check_condition_castend_unknown(struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv) { int hIndex = 0; if( HPMHooks.count.HP_skill_check_condition_castend_unknown_pre ) { - void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv); + void (*preHookFunc) (struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_check_condition_castend_unknown_pre[hIndex].func; - preHookFunc(sd, skill_id, skill_lv); + preHookFunc(&sd, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70650,11 +71008,11 @@ bool HP_skill_get_requirement_off_unknown(struct status_change *sc, uint16 *skil int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_get_requirement_off_unknown_pre ) { - bool (*preHookFunc) (struct status_change *sc, uint16 *skill_id); + bool (*preHookFunc) (struct status_change **sc, uint16 **skill_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_off_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_requirement_off_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, skill_id); + retVal___ = preHookFunc(&sc, &skill_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70677,11 +71035,11 @@ bool HP_skill_get_requirement_item_unknown(struct status_change *sc, struct map_ int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_skill_get_requirement_item_unknown_pre ) { - bool (*preHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i); + bool (*preHookFunc) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, uint16 **idx, int **i); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_item_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_requirement_item_unknown_pre[hIndex].func; - retVal___ = preHookFunc(sc, sd, skill_id, skill_lv, idx, i); + retVal___ = preHookFunc(&sc, &sd, &skill_id, &skill_lv, &idx, &i); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70703,11 +71061,11 @@ bool HP_skill_get_requirement_item_unknown(struct status_change *sc, struct map_ void HP_skill_get_requirement_unknown(struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req) { int hIndex = 0; if( HPMHooks.count.HP_skill_get_requirement_unknown_pre ) { - void (*preHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req); + void (*preHookFunc) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, struct skill_condition **req); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_unknown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_skill_get_requirement_unknown_pre[hIndex].func; - preHookFunc(sc, sd, skill_id, skill_lv, req); + preHookFunc(&sc, &sd, &skill_id, &skill_lv, &req); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70726,6 +71084,99 @@ void HP_skill_get_requirement_unknown(struct status_change *sc, struct map_sessi } return; } +int HP_skill_splash_target(struct block_list *bl) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_skill_splash_target_pre ) { + int (*preHookFunc) (struct block_list **bl); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_splash_target_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_skill_splash_target_pre[hIndex].func; + retVal___ = preHookFunc(&bl); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.skill.splash_target(bl); + } + if( HPMHooks.count.HP_skill_splash_target_post ) { + int (*postHookFunc) (int retVal___, struct block_list *bl); + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_splash_target_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_skill_splash_target_post[hIndex].func; + retVal___ = postHookFunc(retVal___, bl); + } + } + return retVal___; +} +int HP_skill_check_npc_chaospanic(struct block_list *bl, va_list args) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_skill_check_npc_chaospanic_pre ) { + int (*preHookFunc) (struct block_list **bl, va_list args); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_npc_chaospanic_pre; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + preHookFunc = HPMHooks.list.HP_skill_check_npc_chaospanic_pre[hIndex].func; + retVal___ = preHookFunc(&bl, args___copy); + va_end(args___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list args___copy; va_copy(args___copy, args); + retVal___ = HPMHooks.source.skill.check_npc_chaospanic(bl, args___copy); + va_end(args___copy); + } + if( HPMHooks.count.HP_skill_check_npc_chaospanic_post ) { + int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args); + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_npc_chaospanic_post; hIndex++ ) { + va_list args___copy; va_copy(args___copy, args); + postHookFunc = HPMHooks.list.HP_skill_check_npc_chaospanic_post[hIndex].func; + retVal___ = postHookFunc(retVal___, bl, args___copy); + va_end(args___copy); + } + } + return retVal___; +} +int HP_skill_count_wos(struct block_list *bl, va_list ap) { + int hIndex = 0; + int retVal___ = 0; + if( HPMHooks.count.HP_skill_count_wos_pre ) { + int (*preHookFunc) (struct block_list **bl, va_list ap); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_count_wos_pre; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + preHookFunc = HPMHooks.list.HP_skill_count_wos_pre[hIndex].func; + retVal___ = preHookFunc(&bl, ap___copy); + va_end(ap___copy); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + va_list ap___copy; va_copy(ap___copy, ap); + retVal___ = HPMHooks.source.skill.count_wos(bl, ap___copy); + va_end(ap___copy); + } + if( HPMHooks.count.HP_skill_count_wos_post ) { + int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap); + for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_count_wos_post; hIndex++ ) { + va_list ap___copy; va_copy(ap___copy, ap); + postHookFunc = HPMHooks.list.HP_skill_count_wos_post[hIndex].func; + retVal___ = postHookFunc(retVal___, bl, ap___copy); + va_end(ap___copy); + } + } + return retVal___; +} /* socket_interface */ void HP_sockt_init(void) { int hIndex = 0; @@ -70798,10 +71249,10 @@ int HP_sockt_perform(int next) { retVal___ = HPMHooks.source.sockt.perform(next); } if( HPMHooks.count.HP_sockt_perform_post ) { - int (*postHookFunc) (int retVal___, int *next); + int (*postHookFunc) (int retVal___, int next); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &next); + retVal___ = postHookFunc(retVal___, next); } } return retVal___; @@ -70824,10 +71275,10 @@ void HP_sockt_datasync(int fd, bool send) { HPMHooks.source.sockt.datasync(fd, send); } if( HPMHooks.count.HP_sockt_datasync_post ) { - void (*postHookFunc) (int *fd, bool *send); + void (*postHookFunc) (int fd, bool send); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func; - postHookFunc(&fd, &send); + postHookFunc(fd, send); } } return; @@ -70851,10 +71302,10 @@ int HP_sockt_make_listen_bind(uint32 ip, uint16 port) { retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port); } if( HPMHooks.count.HP_sockt_make_listen_bind_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port); + retVal___ = postHookFunc(retVal___, ip, port); } } return retVal___; @@ -70863,11 +71314,11 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_make_connection_pre ) { - int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt **opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func; - retVal___ = preHookFunc(&ip, &port, opt); + retVal___ = preHookFunc(&ip, &port, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -70878,10 +71329,10 @@ int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) { retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt); } if( HPMHooks.count.HP_sockt_make_connection_post ) { - int (*postHookFunc) (int retVal___, uint32 *ip, uint16 *port, struct hSockOpt *opt); + int (*postHookFunc) (int retVal___, uint32 ip, uint16 port, struct hSockOpt *opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, &port, opt); + retVal___ = postHookFunc(retVal___, ip, port, opt); } } return retVal___; @@ -70905,10 +71356,10 @@ int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_si retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size); } if( HPMHooks.count.HP_sockt_realloc_fifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size); + int (*postHookFunc) (int retVal___, int fd, unsigned int rfifo_size, unsigned int wfifo_size); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &rfifo_size, &wfifo_size); + retVal___ = postHookFunc(retVal___, fd, rfifo_size, wfifo_size); } } return retVal___; @@ -70932,10 +71383,10 @@ int HP_sockt_realloc_writefifo(int fd, size_t addition) { retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition); } if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *addition); + int (*postHookFunc) (int retVal___, int fd, size_t addition); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &addition); + retVal___ = postHookFunc(retVal___, fd, addition); } } return retVal___; @@ -70959,10 +71410,10 @@ int HP_sockt_wfifoset(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.wfifoset(fd, len); } if( HPMHooks.count.HP_sockt_wfifoset_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -70986,10 +71437,10 @@ int HP_sockt_rfifoskip(int fd, size_t len) { retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len); } if( HPMHooks.count.HP_sockt_rfifoskip_post ) { - int (*postHookFunc) (int retVal___, int *fd, size_t *len); + int (*postHookFunc) (int retVal___, int fd, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd, &len); + retVal___ = postHookFunc(retVal___, fd, len); } } return retVal___; @@ -71012,10 +71463,10 @@ void HP_sockt_close(int fd) { HPMHooks.source.sockt.close(fd); } if( HPMHooks.count.HP_sockt_close_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -71039,10 +71490,10 @@ bool HP_sockt_session_is_valid(int fd) { retVal___ = HPMHooks.source.sockt.session_is_valid(fd); } if( HPMHooks.count.HP_sockt_session_is_valid_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -71066,10 +71517,10 @@ bool HP_sockt_session_is_active(int fd) { retVal___ = HPMHooks.source.sockt.session_is_active(fd); } if( HPMHooks.count.HP_sockt_session_is_active_post ) { - bool (*postHookFunc) (bool retVal___, int *fd); + bool (*postHookFunc) (bool retVal___, int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &fd); + retVal___ = postHookFunc(retVal___, fd); } } return retVal___; @@ -71092,10 +71543,10 @@ void HP_sockt_flush(int fd) { HPMHooks.source.sockt.flush(fd); } if( HPMHooks.count.HP_sockt_flush_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -71144,10 +71595,10 @@ void HP_sockt_set_nonblocking(int fd, unsigned long yes) { HPMHooks.source.sockt.set_nonblocking(fd, yes); } if( HPMHooks.count.HP_sockt_set_nonblocking_post ) { - void (*postHookFunc) (int *fd, unsigned long *yes); + void (*postHookFunc) (int fd, unsigned long yes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func; - postHookFunc(&fd, &yes); + postHookFunc(fd, yes); } } return; @@ -71170,10 +71621,10 @@ void HP_sockt_set_defaultparse(ParseFunc defaultparse) { HPMHooks.source.sockt.set_defaultparse(defaultparse); } if( HPMHooks.count.HP_sockt_set_defaultparse_post ) { - void (*postHookFunc) (ParseFunc *defaultparse); + void (*postHookFunc) (ParseFunc defaultparse); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func; - postHookFunc(&defaultparse); + postHookFunc(defaultparse); } } return; @@ -71182,11 +71633,11 @@ uint32 HP_sockt_host2ip(const char *hostname) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_host2ip_pre ) { - uint32 (*preHookFunc) (const char *hostname); + uint32 (*preHookFunc) (const char **hostname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func; - retVal___ = preHookFunc(hostname); + retVal___ = preHookFunc(&hostname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71209,11 +71660,11 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sockt_ip2str_pre ) { - const char* (*preHookFunc) (uint32 *ip, char *ip_str); + const char* (*preHookFunc) (uint32 *ip, char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func; - retVal___ = preHookFunc(&ip, ip_str); + retVal___ = preHookFunc(&ip, &ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71224,10 +71675,10 @@ const char* HP_sockt_ip2str(uint32 ip, char *ip_str) { retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str); } if( HPMHooks.count.HP_sockt_ip2str_post ) { - const char* (*postHookFunc) (const char* retVal___, uint32 *ip, char *ip_str); + const char* (*postHookFunc) (const char* retVal___, uint32 ip, char *ip_str); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, ip_str); + retVal___ = postHookFunc(retVal___, ip, ip_str); } } return retVal___; @@ -71236,11 +71687,11 @@ uint32 HP_sockt_str2ip(const char *ip_str) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_str2ip_pre ) { - uint32 (*preHookFunc) (const char *ip_str); + uint32 (*preHookFunc) (const char **ip_str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func; - retVal___ = preHookFunc(ip_str); + retVal___ = preHookFunc(&ip_str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71278,10 +71729,10 @@ uint16 HP_sockt_ntows(uint16 netshort) { retVal___ = HPMHooks.source.sockt.ntows(netshort); } if( HPMHooks.count.HP_sockt_ntows_post ) { - uint16 (*postHookFunc) (uint16 retVal___, uint16 *netshort); + uint16 (*postHookFunc) (uint16 retVal___, uint16 netshort); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &netshort); + retVal___ = postHookFunc(retVal___, netshort); } } return retVal___; @@ -71290,11 +71741,11 @@ int HP_sockt_getips(uint32 *ips, int max) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_getips_pre ) { - int (*preHookFunc) (uint32 *ips, int *max); + int (*preHookFunc) (uint32 **ips, int *max); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func; - retVal___ = preHookFunc(ips, &max); + retVal___ = preHookFunc(&ips, &max); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71305,10 +71756,10 @@ int HP_sockt_getips(uint32 *ips, int max) { retVal___ = HPMHooks.source.sockt.getips(ips, max); } if( HPMHooks.count.HP_sockt_getips_post ) { - int (*postHookFunc) (int retVal___, uint32 *ips, int *max); + int (*postHookFunc) (int retVal___, uint32 *ips, int max); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ips, &max); + retVal___ = postHookFunc(retVal___, ips, max); } } return retVal___; @@ -71331,10 +71782,10 @@ void HP_sockt_eof(int fd) { HPMHooks.source.sockt.eof(fd); } if( HPMHooks.count.HP_sockt_eof_post ) { - void (*postHookFunc) (int *fd); + void (*postHookFunc) (int fd); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func; - postHookFunc(&fd); + postHookFunc(fd); } } return; @@ -71343,11 +71794,11 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) { - uint32 (*preHookFunc) (uint32 *ip, struct s_subnet *info); + uint32 (*preHookFunc) (uint32 *ip, struct s_subnet **info); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func; - retVal___ = preHookFunc(&ip, info); + retVal___ = preHookFunc(&ip, &info); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71358,10 +71809,10 @@ uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) { retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info); } if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) { - uint32 (*postHookFunc) (uint32 retVal___, uint32 *ip, struct s_subnet *info); + uint32 (*postHookFunc) (uint32 retVal___, uint32 ip, struct s_subnet *info); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip, info); + retVal___ = postHookFunc(retVal___, ip, info); } } return retVal___; @@ -71385,10 +71836,10 @@ bool HP_sockt_allowed_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip); } if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -71412,10 +71863,10 @@ bool HP_sockt_trusted_ip_check(uint32 ip) { retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip); } if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) { - bool (*postHookFunc) (bool retVal___, uint32 *ip); + bool (*postHookFunc) (bool retVal___, uint32 ip); for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &ip); + retVal___ = postHookFunc(retVal___, ip); } } return retVal___; @@ -71424,11 +71875,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname); + int (*preHookFunc) (struct config_setting_t **t, struct s_subnet_vector **list, const char **filename, const char **groupname); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func; - retVal___ = preHookFunc(t, list, filename, groupname); + retVal___ = preHookFunc(&t, &list, &filename, &groupname); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71450,11 +71901,11 @@ int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vec void HP_sockt_net_config_read(const char *filename) { int hIndex = 0; if( HPMHooks.count.HP_sockt_net_config_read_pre ) { - void (*preHookFunc) (const char *filename); + void (*preHookFunc) (const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func; - preHookFunc(filename); + preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71478,11 +71929,11 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Connect_pre ) { - int (*preHookFunc) (struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*preHookFunc) (struct Sql **self, const char **user, const char **passwd, const char **host, uint16 *port, const char **db); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func; - retVal___ = preHookFunc(self, user, passwd, host, &port, db); + retVal___ = preHookFunc(&self, &user, &passwd, &host, &port, &db); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71493,10 +71944,10 @@ int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db); } if( HPMHooks.count.HP_SQL_Connect_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 *port, const char *db); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, user, passwd, host, &port, db); + retVal___ = postHookFunc(retVal___, self, user, passwd, host, port, db); } } return retVal___; @@ -71505,11 +71956,11 @@ int HP_SQL_GetTimeout(struct Sql *self, uint32 *out_timeout) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetTimeout_pre ) { - int (*preHookFunc) (struct Sql *self, uint32 *out_timeout); + int (*preHookFunc) (struct Sql **self, uint32 **out_timeout); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func; - retVal___ = preHookFunc(self, out_timeout); + retVal___ = preHookFunc(&self, &out_timeout); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71532,11 +71983,11 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) { - int (*preHookFunc) (struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*preHookFunc) (struct Sql **self, const char **table, char **out_buf, size_t *buf_len, char *sep); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func; - retVal___ = preHookFunc(self, table, out_buf, &buf_len, &sep); + retVal___ = preHookFunc(&self, &table, &out_buf, &buf_len, &sep); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71547,10 +71998,10 @@ int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, si retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep); } if( HPMHooks.count.HP_SQL_GetColumnNames_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t *buf_len, char *sep); + int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, table, out_buf, &buf_len, &sep); + retVal___ = postHookFunc(retVal___, self, table, out_buf, buf_len, sep); } } return retVal___; @@ -71559,11 +72010,11 @@ int HP_SQL_SetEncoding(struct Sql *self, const char *encoding) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_SetEncoding_pre ) { - int (*preHookFunc) (struct Sql *self, const char *encoding); + int (*preHookFunc) (struct Sql **self, const char **encoding); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func; - retVal___ = preHookFunc(self, encoding); + retVal___ = preHookFunc(&self, &encoding); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71586,11 +72037,11 @@ int HP_SQL_Ping(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_Ping_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71613,11 +72064,11 @@ size_t HP_SQL_EscapeString(struct Sql *self, char *out_to, const char *from) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeString_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from); + retVal___ = preHookFunc(&self, &out_to, &from); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71640,11 +72091,11 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) { - size_t (*preHookFunc) (struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from, size_t *from_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func; - retVal___ = preHookFunc(self, out_to, from, &from_len); + retVal___ = preHookFunc(&self, &out_to, &from, &from_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71655,10 +72106,10 @@ size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len); } if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) { - size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t *from_len); + size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t from_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, out_to, from, &from_len); + retVal___ = postHookFunc(retVal___, self, out_to, from, from_len); } } return retVal___; @@ -71667,12 +72118,12 @@ int HP_SQL_QueryV(struct Sql *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryV_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query, va_list args); + int (*preHookFunc) (struct Sql **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -71700,11 +72151,11 @@ int HP_SQL_QueryStr(struct Sql *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_QueryStr_pre ) { - int (*preHookFunc) (struct Sql *self, const char *query); + int (*preHookFunc) (struct Sql **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71727,11 +72178,11 @@ uint64 HP_SQL_LastInsertId(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_LastInsertId_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71754,11 +72205,11 @@ uint32 HP_SQL_NumColumns(struct Sql *self) { int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumColumns_pre ) { - uint32 (*preHookFunc) (struct Sql *self); + uint32 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71781,11 +72232,11 @@ uint64 HP_SQL_NumRows(struct Sql *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_NumRows_pre ) { - uint64 (*preHookFunc) (struct Sql *self); + uint64 (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71808,11 +72259,11 @@ int HP_SQL_NextRow(struct Sql *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_NextRow_pre ) { - int (*preHookFunc) (struct Sql *self); + int (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71835,11 +72286,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_GetData_pre ) { - int (*preHookFunc) (struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*preHookFunc) (struct Sql **self, size_t *col, char ***out_buf, size_t **out_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func; - retVal___ = preHookFunc(self, &col, out_buf, out_len); + retVal___ = preHookFunc(&self, &col, &out_buf, &out_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71850,10 +72301,10 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len); } if( HPMHooks.count.HP_SQL_GetData_post ) { - int (*postHookFunc) (int retVal___, struct Sql *self, size_t *col, char **out_buf, size_t *out_len); + int (*postHookFunc) (int retVal___, struct Sql *self, size_t col, char **out_buf, size_t *out_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &col, out_buf, out_len); + retVal___ = postHookFunc(retVal___, self, col, out_buf, out_len); } } return retVal___; @@ -71861,11 +72312,11 @@ int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len void HP_SQL_FreeResult(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_FreeResult_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71887,11 +72338,11 @@ void HP_SQL_FreeResult(struct Sql *self) { void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_ShowDebug__pre ) { - void (*preHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct Sql **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71902,10 +72353,10 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_ShowDebug__post ) { - void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -71913,11 +72364,11 @@ void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned void HP_SQL_Free(struct Sql *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_Free_pre ) { - void (*preHookFunc) (struct Sql *self); + void (*preHookFunc) (struct Sql **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71967,11 +72418,11 @@ struct SqlStmt* HP_SQL_StmtMalloc(struct Sql *sql) { int hIndex = 0; struct SqlStmt* retVal___ = NULL; if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) { - struct SqlStmt* (*preHookFunc) (struct Sql *sql); + struct SqlStmt* (*preHookFunc) (struct Sql **sql); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func; - retVal___ = preHookFunc(sql); + retVal___ = preHookFunc(&sql); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -71994,12 +72445,12 @@ int HP_SQL_StmtPrepareV(struct SqlStmt *self, const char *query, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query, va_list args); + int (*preHookFunc) (struct SqlStmt **self, const char **query, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func; - retVal___ = preHookFunc(self, query, args___copy); + retVal___ = preHookFunc(&self, &query, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -72027,11 +72478,11 @@ int HP_SQL_StmtPrepareStr(struct SqlStmt *self, const char *query) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) { - int (*preHookFunc) (struct SqlStmt *self, const char *query); + int (*preHookFunc) (struct SqlStmt **self, const char **query); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func; - retVal___ = preHookFunc(self, query); + retVal___ = preHookFunc(&self, &query); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72054,11 +72505,11 @@ size_t HP_SQL_StmtNumParams(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72081,11 +72532,11 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const void **buffer, size_t *buffer_len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72096,10 +72547,10 @@ int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buff retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len); } if( HPMHooks.count.HP_SQL_StmtBindParam_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, const void *buffer, size_t *buffer_len); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len); } } return retVal___; @@ -72108,11 +72559,11 @@ int HP_SQL_StmtExecute(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtExecute_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72135,11 +72586,11 @@ uint64 HP_SQL_StmtLastInsertId(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72162,11 +72613,11 @@ size_t HP_SQL_StmtNumColumns(struct SqlStmt *self) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) { - size_t (*preHookFunc) (struct SqlStmt *self); + size_t (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72189,11 +72640,11 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) { - int (*preHookFunc) (struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, void **buffer, size_t *buffer_len, uint32 **out_length, int8 **out_is_null); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func; - retVal___ = preHookFunc(self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len, &out_length, &out_is_null); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72204,10 +72655,10 @@ int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buf retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) { - int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t *idx, enum SqlDataType *buffer_type, void *buffer, size_t *buffer_len, uint32 *out_length, int8 *out_is_null); + int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func; - retVal___ = postHookFunc(retVal___, self, &idx, &buffer_type, buffer, &buffer_len, out_length, out_is_null); + retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null); } } return retVal___; @@ -72216,11 +72667,11 @@ uint64 HP_SQL_StmtNumRows(struct SqlStmt *self) { int hIndex = 0; uint64 retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) { - uint64 (*preHookFunc) (struct SqlStmt *self); + uint64 (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72243,11 +72694,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) { - int (*preHookFunc) (struct SqlStmt *self); + int (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72269,11 +72720,11 @@ int HP_SQL_StmtNextRow(struct SqlStmt *self) { void HP_SQL_StmtFreeResult(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72295,11 +72746,11 @@ void HP_SQL_StmtFreeResult(struct SqlStmt *self) { void HP_SQL_StmtFree(struct SqlStmt *self) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtFree_pre ) { - void (*preHookFunc) (struct SqlStmt *self); + void (*preHookFunc) (struct SqlStmt **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72321,11 +72772,11 @@ void HP_SQL_StmtFree(struct SqlStmt *self) { void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const unsigned long debug_line) { int hIndex = 0; if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) { - void (*preHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*preHookFunc) (struct SqlStmt **self, const char **debug_file, const unsigned long *debug_line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func; - preHookFunc(self, debug_file, &debug_line); + preHookFunc(&self, &debug_file, &debug_line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72336,10 +72787,10 @@ void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const u HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line); } if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) { - void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long *debug_line); + void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long debug_line); for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func; - postHookFunc(self, debug_file, &debug_line); + postHookFunc(self, debug_file, debug_line); } } return; @@ -72364,10 +72815,10 @@ int HP_status_init(bool minimal) { retVal___ = HPMHooks.source.status.init(minimal); } if( HPMHooks.count.HP_status_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -72417,10 +72868,10 @@ int HP_status_get_refine_chance(enum refine_type wlv, int refine) { retVal___ = HPMHooks.source.status.get_refine_chance(wlv, refine); } if( HPMHooks.count.HP_status_get_refine_chance_post ) { - int (*postHookFunc) (int retVal___, enum refine_type *wlv, int *refine); + int (*postHookFunc) (int retVal___, enum refine_type wlv, int refine); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_refine_chance_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_get_refine_chance_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &wlv, &refine); + retVal___ = postHookFunc(retVal___, wlv, refine); } } return retVal___; @@ -72444,10 +72895,10 @@ sc_type HP_status_skill2sc(int skill_id) { retVal___ = HPMHooks.source.status.skill2sc(skill_id); } if( HPMHooks.count.HP_status_skill2sc_post ) { - sc_type (*postHookFunc) (sc_type retVal___, int *skill_id); + sc_type (*postHookFunc) (sc_type retVal___, int skill_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_skill2sc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_skill2sc_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &skill_id); + retVal___ = postHookFunc(retVal___, skill_id); } } return retVal___; @@ -72471,10 +72922,10 @@ int HP_status_sc2skill(sc_type sc) { retVal___ = HPMHooks.source.status.sc2skill(sc); } if( HPMHooks.count.HP_status_sc2skill_post ) { - int (*postHookFunc) (int retVal___, sc_type *sc); + int (*postHookFunc) (int retVal___, sc_type sc); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2skill_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_sc2skill_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &sc); + retVal___ = postHookFunc(retVal___, sc); } } return retVal___; @@ -72498,10 +72949,10 @@ unsigned int HP_status_sc2scb_flag(sc_type sc) { retVal___ = HPMHooks.source.status.sc2scb_flag(sc); } if( HPMHooks.count.HP_status_sc2scb_flag_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, sc_type *sc); + unsigned int (*postHookFunc) (unsigned int retVal___, sc_type sc); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2scb_flag_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_sc2scb_flag_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &sc); + retVal___ = postHookFunc(retVal___, sc); } } return retVal___; @@ -72525,10 +72976,10 @@ int HP_status_type2relevant_bl_types(int type) { retVal___ = HPMHooks.source.status.type2relevant_bl_types(type); } if( HPMHooks.count.HP_status_type2relevant_bl_types_post ) { - int (*postHookFunc) (int retVal___, int *type); + int (*postHookFunc) (int retVal___, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_type2relevant_bl_types_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_type2relevant_bl_types_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &type); + retVal___ = postHookFunc(retVal___, type); } } return retVal___; @@ -72552,10 +73003,10 @@ int HP_status_get_sc_type(sc_type idx) { retVal___ = HPMHooks.source.status.get_sc_type(idx); } if( HPMHooks.count.HP_status_get_sc_type_post ) { - int (*postHookFunc) (int retVal___, sc_type *idx); + int (*postHookFunc) (int retVal___, sc_type idx); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_type_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_get_sc_type_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &idx); + retVal___ = postHookFunc(retVal___, idx); } } return retVal___; @@ -72564,11 +73015,11 @@ int HP_status_damage(struct block_list *src, struct block_list *target, int64 hp int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_damage_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, int64 *hp, int64 *sp, int *walkdelay, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, int64 *hp, int64 *sp, int *walkdelay, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_damage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_damage_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &hp, &sp, &walkdelay, &flag); + retVal___ = preHookFunc(&src, &target, &hp, &sp, &walkdelay, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72579,10 +73030,10 @@ int HP_status_damage(struct block_list *src, struct block_list *target, int64 hp retVal___ = HPMHooks.source.status.damage(src, target, hp, sp, walkdelay, flag); } if( HPMHooks.count.HP_status_damage_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int64 *hp, int64 *sp, int *walkdelay, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int64 hp, int64 sp, int walkdelay, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_damage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_damage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &hp, &sp, &walkdelay, &flag); + retVal___ = postHookFunc(retVal___, src, target, hp, sp, walkdelay, flag); } } return retVal___; @@ -72591,11 +73042,11 @@ int HP_status_charge(struct block_list *bl, int64 hp, int64 sp) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_charge_pre ) { - int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp); + int (*preHookFunc) (struct block_list **bl, int64 *hp, int64 *sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_charge_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_charge_pre[hIndex].func; - retVal___ = preHookFunc(bl, &hp, &sp); + retVal___ = preHookFunc(&bl, &hp, &sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72606,10 +73057,10 @@ int HP_status_charge(struct block_list *bl, int64 hp, int64 sp) { retVal___ = HPMHooks.source.status.charge(bl, hp, sp); } if( HPMHooks.count.HP_status_charge_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *hp, int64 *sp); + int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_charge_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_charge_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &hp, &sp); + retVal___ = postHookFunc(retVal___, bl, hp, sp); } } return retVal___; @@ -72618,11 +73069,11 @@ int HP_status_percent_change(struct block_list *src, struct block_list *target, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_percent_change_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, signed char *hp_rate, signed char *sp_rate, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, signed char *hp_rate, signed char *sp_rate, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_percent_change_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_percent_change_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &hp_rate, &sp_rate, &flag); + retVal___ = preHookFunc(&src, &target, &hp_rate, &sp_rate, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72633,10 +73084,10 @@ int HP_status_percent_change(struct block_list *src, struct block_list *target, retVal___ = HPMHooks.source.status.percent_change(src, target, hp_rate, sp_rate, flag); } if( HPMHooks.count.HP_status_percent_change_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, signed char *hp_rate, signed char *sp_rate, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, signed char hp_rate, signed char sp_rate, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_percent_change_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_percent_change_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &hp_rate, &sp_rate, &flag); + retVal___ = postHookFunc(retVal___, src, target, hp_rate, sp_rate, flag); } } return retVal___; @@ -72645,11 +73096,11 @@ int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_set_hp_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned int *hp, int *flag); + int (*preHookFunc) (struct block_list **bl, unsigned int *hp, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_set_hp_pre[hIndex].func; - retVal___ = preHookFunc(bl, &hp, &flag); + retVal___ = preHookFunc(&bl, &hp, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72660,10 +73111,10 @@ int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) { retVal___ = HPMHooks.source.status.set_hp(bl, hp, flag); } if( HPMHooks.count.HP_status_set_hp_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *hp, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int hp, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_set_hp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &hp, &flag); + retVal___ = postHookFunc(retVal___, bl, hp, flag); } } return retVal___; @@ -72672,11 +73123,11 @@ int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_set_sp_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned int *sp, int *flag); + int (*preHookFunc) (struct block_list **bl, unsigned int *sp, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_set_sp_pre[hIndex].func; - retVal___ = preHookFunc(bl, &sp, &flag); + retVal___ = preHookFunc(&bl, &sp, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72687,10 +73138,10 @@ int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) { retVal___ = HPMHooks.source.status.set_sp(bl, sp, flag); } if( HPMHooks.count.HP_status_set_sp_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *sp, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int sp, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_set_sp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &sp, &flag); + retVal___ = postHookFunc(retVal___, bl, sp, flag); } } return retVal___; @@ -72699,11 +73150,11 @@ int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_heal_pre ) { - int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp, int *flag); + int (*preHookFunc) (struct block_list **bl, int64 *hp, int64 *sp, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_heal_pre[hIndex].func; - retVal___ = preHookFunc(bl, &hp, &sp, &flag); + retVal___ = preHookFunc(&bl, &hp, &sp, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72714,10 +73165,10 @@ int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) { retVal___ = HPMHooks.source.status.heal(bl, hp, sp, flag); } if( HPMHooks.count.HP_status_heal_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *hp, int64 *sp, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_heal_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &hp, &sp, &flag); + retVal___ = postHookFunc(retVal___, bl, hp, sp, flag); } } return retVal___; @@ -72726,11 +73177,11 @@ int HP_status_revive(struct block_list *bl, unsigned char per_hp, unsigned char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_revive_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned char *per_hp, unsigned char *per_sp); + int (*preHookFunc) (struct block_list **bl, unsigned char *per_hp, unsigned char *per_sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_revive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_revive_pre[hIndex].func; - retVal___ = preHookFunc(bl, &per_hp, &per_sp); + retVal___ = preHookFunc(&bl, &per_hp, &per_sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72741,10 +73192,10 @@ int HP_status_revive(struct block_list *bl, unsigned char per_hp, unsigned char retVal___ = HPMHooks.source.status.revive(bl, per_hp, per_sp); } if( HPMHooks.count.HP_status_revive_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char *per_hp, unsigned char *per_sp); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char per_hp, unsigned char per_sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_revive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_revive_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &per_hp, &per_sp); + retVal___ = postHookFunc(retVal___, bl, per_hp, per_sp); } } return retVal___; @@ -72753,11 +73204,11 @@ int HP_status_fixed_revive(struct block_list *bl, unsigned int per_hp, unsigned int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_fixed_revive_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned int *per_hp, unsigned int *per_sp); + int (*preHookFunc) (struct block_list **bl, unsigned int *per_hp, unsigned int *per_sp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_fixed_revive_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_fixed_revive_pre[hIndex].func; - retVal___ = preHookFunc(bl, &per_hp, &per_sp); + retVal___ = preHookFunc(&bl, &per_hp, &per_sp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72768,10 +73219,10 @@ int HP_status_fixed_revive(struct block_list *bl, unsigned int per_hp, unsigned retVal___ = HPMHooks.source.status.fixed_revive(bl, per_hp, per_sp); } if( HPMHooks.count.HP_status_fixed_revive_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *per_hp, unsigned int *per_sp); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int per_hp, unsigned int per_sp); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_fixed_revive_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_fixed_revive_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &per_hp, &per_sp); + retVal___ = postHookFunc(retVal___, bl, per_hp, per_sp); } } return retVal___; @@ -72780,11 +73231,11 @@ struct regen_data* HP_status_get_regen_data(struct block_list *bl) { int hIndex = 0; struct regen_data* retVal___ = NULL; if( HPMHooks.count.HP_status_get_regen_data_pre ) { - struct regen_data* (*preHookFunc) (struct block_list *bl); + struct regen_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_regen_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_regen_data_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72807,11 +73258,11 @@ struct status_data* HP_status_get_status_data(struct block_list *bl) { int hIndex = 0; struct status_data* retVal___ = NULL; if( HPMHooks.count.HP_status_get_status_data_pre ) { - struct status_data* (*preHookFunc) (struct block_list *bl); + struct status_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_status_data_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_status_data_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72834,11 +73285,11 @@ struct status_data* HP_status_get_base_status(struct block_list *bl) { int hIndex = 0; struct status_data* retVal___ = NULL; if( HPMHooks.count.HP_status_get_base_status_pre ) { - struct status_data* (*preHookFunc) (struct block_list *bl); + struct status_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_status_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_base_status_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72861,11 +73312,11 @@ const char* HP_status_get_name(const struct block_list *bl) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_status_get_name_pre ) { - const char* (*preHookFunc) (const struct block_list *bl); + const char* (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_name_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_name_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72888,11 +73339,11 @@ int HP_status_get_class(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_class_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_class_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_class_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72915,11 +73366,11 @@ int HP_status_get_lv(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_lv_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_lv_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_lv_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72942,11 +73393,11 @@ defType HP_status_get_def(struct block_list *bl) { int hIndex = 0; defType retVal___ = 0; if( HPMHooks.count.HP_status_get_def_pre ) { - defType (*preHookFunc) (struct block_list *bl); + defType (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_def_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_def_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72969,11 +73420,11 @@ unsigned short HP_status_get_speed(struct block_list *bl) { int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_get_speed_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl); + unsigned short (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_speed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_speed_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -72996,11 +73447,11 @@ unsigned char HP_status_calc_attack_element(struct block_list *bl, struct status int hIndex = 0; unsigned char retVal___ = 0; if( HPMHooks.count.HP_status_calc_attack_element_pre ) { - unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element); + unsigned char (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *element); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_attack_element_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_attack_element_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &element); + retVal___ = preHookFunc(&bl, &sc, &element); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73011,10 +73462,10 @@ unsigned char HP_status_calc_attack_element(struct block_list *bl, struct status retVal___ = HPMHooks.source.status.calc_attack_element(bl, sc, element); } if( HPMHooks.count.HP_status_calc_attack_element_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *element); + unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_attack_element_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_attack_element_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &element); + retVal___ = postHookFunc(retVal___, bl, sc, element); } } return retVal___; @@ -73023,11 +73474,11 @@ int HP_status_get_party_id(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_party_id_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_party_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_party_id_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73050,11 +73501,11 @@ int HP_status_get_guild_id(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_guild_id_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_guild_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_guild_id_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73077,11 +73528,11 @@ int HP_status_get_emblem_id(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_emblem_id_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_emblem_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_emblem_id_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73104,11 +73555,11 @@ int HP_status_get_mexp(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_mexp_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_mexp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_mexp_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73131,11 +73582,11 @@ int HP_status_get_race2(const struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_race2_pre ) { - int (*preHookFunc) (const struct block_list *bl); + int (*preHookFunc) (const struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_race2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_race2_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73158,11 +73609,11 @@ struct view_data* HP_status_get_viewdata(struct block_list *bl) { int hIndex = 0; struct view_data* retVal___ = NULL; if( HPMHooks.count.HP_status_get_viewdata_pre ) { - struct view_data* (*preHookFunc) (struct block_list *bl); + struct view_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_viewdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_viewdata_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73184,11 +73635,11 @@ struct view_data* HP_status_get_viewdata(struct block_list *bl) { void HP_status_set_viewdata(struct block_list *bl, int class_) { int hIndex = 0; if( HPMHooks.count.HP_status_set_viewdata_pre ) { - void (*preHookFunc) (struct block_list *bl, int *class_); + void (*preHookFunc) (struct block_list **bl, int *class_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_viewdata_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_set_viewdata_pre[hIndex].func; - preHookFunc(bl, &class_); + preHookFunc(&bl, &class_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73199,10 +73650,10 @@ void HP_status_set_viewdata(struct block_list *bl, int class_) { HPMHooks.source.status.set_viewdata(bl, class_); } if( HPMHooks.count.HP_status_set_viewdata_post ) { - void (*postHookFunc) (struct block_list *bl, int *class_); + void (*postHookFunc) (struct block_list *bl, int class_); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_viewdata_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_set_viewdata_post[hIndex].func; - postHookFunc(bl, &class_); + postHookFunc(bl, class_); } } return; @@ -73210,11 +73661,11 @@ void HP_status_set_viewdata(struct block_list *bl, int class_) { void HP_status_change_init(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_status_change_init_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_init_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73237,11 +73688,11 @@ struct status_change* HP_status_get_sc(struct block_list *bl) { int hIndex = 0; struct status_change* retVal___ = NULL; if( HPMHooks.count.HP_status_get_sc_pre ) { - struct status_change* (*preHookFunc) (struct block_list *bl); + struct status_change* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_sc_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73264,11 +73715,11 @@ int HP_status_isdead(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_isdead_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isdead_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_isdead_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73291,11 +73742,11 @@ int HP_status_isimmune(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_isimmune_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isimmune_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_isimmune_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73318,11 +73769,11 @@ int HP_status_get_sc_def(struct block_list *src, struct block_list *bl, enum sc_ int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_sc_def_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *tick, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, enum sc_type *type, int *rate, int *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_def_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_sc_def_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &type, &rate, &tick, &flag); + retVal___ = preHookFunc(&src, &bl, &type, &rate, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73333,10 +73784,10 @@ int HP_status_get_sc_def(struct block_list *src, struct block_list *bl, enum sc_ retVal___ = HPMHooks.source.status.get_sc_def(src, bl, type, rate, tick, flag); } if( HPMHooks.count.HP_status_get_sc_def_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_def_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_get_sc_def_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &type, &rate, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, bl, type, rate, tick, flag); } } return retVal___; @@ -73345,11 +73796,11 @@ int HP_status_change_start(struct block_list *src, struct block_list *bl, enum s int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_start_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_start_pre[hIndex].func; - retVal___ = preHookFunc(src, bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag); + retVal___ = preHookFunc(&src, &bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73360,10 +73811,10 @@ int HP_status_change_start(struct block_list *src, struct block_list *bl, enum s retVal___ = HPMHooks.source.status.change_start(src, bl, type, rate, val1, val2, val3, val4, tick, flag); } if( HPMHooks.count.HP_status_change_start_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int val1, int val2, int val3, int val4, int tick, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_change_start_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag); + retVal___ = postHookFunc(retVal___, src, bl, type, rate, val1, val2, val3, val4, tick, flag); } } return retVal___; @@ -73372,11 +73823,11 @@ int HP_status_change_end_(struct block_list *bl, enum sc_type type, int tid, con int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_end__pre ) { - int (*preHookFunc) (struct block_list *bl, enum sc_type *type, int *tid, const char *file, int *line); + int (*preHookFunc) (struct block_list **bl, enum sc_type *type, int *tid, const char **file, int *line); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_end__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_end__pre[hIndex].func; - retVal___ = preHookFunc(bl, &type, &tid, file, &line); + retVal___ = preHookFunc(&bl, &type, &tid, &file, &line); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73387,10 +73838,10 @@ int HP_status_change_end_(struct block_list *bl, enum sc_type type, int tid, con retVal___ = HPMHooks.source.status.change_end_(bl, type, tid, file, line); } if( HPMHooks.count.HP_status_change_end__post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, int *tid, const char *file, int *line); + int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type type, int tid, const char *file, int line); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_end__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_change_end__post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type, &tid, file, &line); + retVal___ = postHookFunc(retVal___, bl, type, tid, file, line); } } return retVal___; @@ -73414,10 +73865,10 @@ int HP_status_kaahi_heal_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.status.kaahi_heal_timer(tid, tick, id, data); } if( HPMHooks.count.HP_status_kaahi_heal_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_kaahi_heal_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_kaahi_heal_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -73441,10 +73892,10 @@ int HP_status_change_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.status.change_timer(tid, tick, id, data); } if( HPMHooks.count.HP_status_change_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_change_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -73453,12 +73904,12 @@ int HP_status_change_timer_sub(struct block_list *bl, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_timer_sub_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list ap); + int (*preHookFunc) (struct block_list **bl, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_status_change_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl, ap___copy); + retVal___ = preHookFunc(&bl, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -73486,11 +73937,11 @@ int HP_status_change_clear(struct block_list *bl, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_clear_pre ) { - int (*preHookFunc) (struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_clear_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type); + retVal___ = preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73501,10 +73952,10 @@ int HP_status_change_clear(struct block_list *bl, int type) { retVal___ = HPMHooks.source.status.change_clear(bl, type); } if( HPMHooks.count.HP_status_change_clear_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_change_clear_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type); + retVal___ = postHookFunc(retVal___, bl, type); } } return retVal___; @@ -73513,11 +73964,11 @@ int HP_status_change_clear_buffs(struct block_list *bl, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_clear_buffs_pre ) { - int (*preHookFunc) (struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_buffs_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_clear_buffs_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type); + retVal___ = preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73528,10 +73979,10 @@ int HP_status_change_clear_buffs(struct block_list *bl, int type) { retVal___ = HPMHooks.source.status.change_clear_buffs(bl, type); } if( HPMHooks.count.HP_status_change_clear_buffs_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_buffs_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_change_clear_buffs_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type); + retVal___ = postHookFunc(retVal___, bl, type); } } return retVal___; @@ -73539,11 +73990,11 @@ int HP_status_change_clear_buffs(struct block_list *bl, int type) { 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, enum e_status_calc_opt *opt); + void (*preHookFunc) (struct block_list **bl, enum scb_flag *flag, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + preHookFunc(&bl, &flag, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73554,10 +74005,10 @@ void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, enum e_status 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, enum e_status_calc_opt *opt); + 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, &opt); + postHookFunc(bl, flag, opt); } } return; @@ -73566,11 +74017,11 @@ 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, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct mob_data **md, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&md, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73581,10 +74032,10 @@ int HP_status_calc_mob_(struct mob_data *md, enum e_status_calc_opt opt) { retVal___ = HPMHooks.source.status.calc_mob_(md, opt); } if( HPMHooks.count.HP_status_calc_mob__post ) { - int (*postHookFunc) (int retVal___, struct mob_data *md, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, md, opt); } } return retVal___; @@ -73593,11 +74044,11 @@ 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, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct pet_data **pd, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&pd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73608,10 +74059,10 @@ int HP_status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt) { retVal___ = HPMHooks.source.status.calc_pet_(pd, opt); } if( HPMHooks.count.HP_status_calc_pet__post ) { - int (*postHookFunc) (int retVal___, struct pet_data *pd, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, pd, opt); } } return retVal___; @@ -73620,11 +74071,11 @@ 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, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct map_session_data **sd, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&sd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73635,10 +74086,10 @@ int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt) 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, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, sd, opt); } } return retVal___; @@ -73646,11 +74097,11 @@ int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt) void HP_status_calc_pc_additional(struct map_session_data *sd, enum e_status_calc_opt opt) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_pc_additional_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt); + void (*preHookFunc) (struct map_session_data **sd, enum e_status_calc_opt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_additional_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_pc_additional_pre[hIndex].func; - preHookFunc(sd, &opt); + preHookFunc(&sd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73661,10 +74112,10 @@ void HP_status_calc_pc_additional(struct map_session_data *sd, enum e_status_cal HPMHooks.source.status.calc_pc_additional(sd, opt); } if( HPMHooks.count.HP_status_calc_pc_additional_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt); + void (*postHookFunc) (struct map_session_data *sd, enum e_status_calc_opt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_additional_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_pc_additional_post[hIndex].func; - postHookFunc(sd, &opt); + postHookFunc(sd, opt); } } return; @@ -73673,11 +74124,11 @@ 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, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct homun_data **hd, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&hd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73688,10 +74139,10 @@ int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt retVal___ = HPMHooks.source.status.calc_homunculus_(hd, opt); } if( HPMHooks.count.HP_status_calc_homunculus__post ) { - int (*postHookFunc) (int retVal___, struct homun_data *hd, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, hd, opt); } } return retVal___; @@ -73700,11 +74151,11 @@ int HP_status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_mercenary__pre ) { - int (*preHookFunc) (struct mercenary_data *md, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct mercenary_data **md, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&md, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73715,10 +74166,10 @@ int HP_status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt retVal___ = HPMHooks.source.status.calc_mercenary_(md, opt); } if( HPMHooks.count.HP_status_calc_mercenary__post ) { - int (*postHookFunc) (int retVal___, struct mercenary_data *md, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, md, opt); } } return retVal___; @@ -73727,11 +74178,11 @@ int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_calc_elemental__pre ) { - int (*preHookFunc) (struct elemental_data *ed, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct elemental_data **ed, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&ed, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73742,10 +74193,10 @@ int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt retVal___ = HPMHooks.source.status.calc_elemental_(ed, opt); } if( HPMHooks.count.HP_status_calc_elemental__post ) { - int (*postHookFunc) (int retVal___, struct elemental_data *ed, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, ed, opt); } } return retVal___; @@ -73753,11 +74204,11 @@ int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt void HP_status_calc_misc(struct block_list *bl, struct status_data *st, int level) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_misc_pre ) { - void (*preHookFunc) (struct block_list *bl, struct status_data *st, int *level); + void (*preHookFunc) (struct block_list **bl, struct status_data **st, int *level); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_misc_pre[hIndex].func; - preHookFunc(bl, st, &level); + preHookFunc(&bl, &st, &level); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73768,10 +74219,10 @@ void HP_status_calc_misc(struct block_list *bl, struct status_data *st, int leve HPMHooks.source.status.calc_misc(bl, st, level); } if( HPMHooks.count.HP_status_calc_misc_post ) { - void (*postHookFunc) (struct block_list *bl, struct status_data *st, int *level); + void (*postHookFunc) (struct block_list *bl, struct status_data *st, int level); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_misc_post[hIndex].func; - postHookFunc(bl, st, &level); + postHookFunc(bl, st, level); } } return; @@ -73779,11 +74230,11 @@ void HP_status_calc_misc(struct block_list *bl, struct status_data *st, int leve void HP_status_calc_regen(struct block_list *bl, struct status_data *st, struct regen_data *regen) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_regen_pre ) { - void (*preHookFunc) (struct block_list *bl, struct status_data *st, struct regen_data *regen); + void (*preHookFunc) (struct block_list **bl, struct status_data **st, struct regen_data **regen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_regen_pre[hIndex].func; - preHookFunc(bl, st, regen); + preHookFunc(&bl, &st, ®en); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73805,11 +74256,11 @@ void HP_status_calc_regen(struct block_list *bl, struct status_data *st, struct void HP_status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_regen_rate_pre ) { - void (*preHookFunc) (struct block_list *bl, struct regen_data *regen, struct status_change *sc); + void (*preHookFunc) (struct block_list **bl, struct regen_data **regen, struct status_change **sc); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_rate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_regen_rate_pre[hIndex].func; - preHookFunc(bl, regen, sc); + preHookFunc(&bl, ®en, &sc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73832,11 +74283,11 @@ int HP_status_check_skilluse(struct block_list *src, struct block_list *target, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_check_skilluse_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, int *flag); + int (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 *skill_id, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_skilluse_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_check_skilluse_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &skill_id, &flag); + retVal___ = preHookFunc(&src, &target, &skill_id, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73847,10 +74298,10 @@ int HP_status_check_skilluse(struct block_list *src, struct block_list *target, retVal___ = HPMHooks.source.status.check_skilluse(src, target, skill_id, flag); } if( HPMHooks.count.HP_status_check_skilluse_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_skilluse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_check_skilluse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &skill_id, &flag); + retVal___ = postHookFunc(retVal___, src, target, skill_id, flag); } } return retVal___; @@ -73859,11 +74310,11 @@ int HP_status_check_visibility(struct block_list *src, struct block_list *target int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_check_visibility_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target); + int (*preHookFunc) (struct block_list **src, struct block_list **target); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_visibility_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_check_visibility_pre[hIndex].func; - retVal___ = preHookFunc(src, target); + retVal___ = preHookFunc(&src, &target); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73886,11 +74337,11 @@ int HP_status_change_spread(struct block_list *src, struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_change_spread_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *bl); + int (*preHookFunc) (struct block_list **src, struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_spread_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_change_spread_pre[hIndex].func; - retVal___ = preHookFunc(src, bl); + retVal___ = preHookFunc(&src, &bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73913,11 +74364,11 @@ defType HP_status_calc_def(struct block_list *bl, struct status_change *sc, int int hIndex = 0; defType retVal___ = 0; if( HPMHooks.count.HP_status_calc_def_pre ) { - defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def, bool *viewable); + defType (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *def, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_def_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &def, &viewable); + retVal___ = preHookFunc(&bl, &sc, &def, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73928,10 +74379,10 @@ defType HP_status_calc_def(struct block_list *bl, struct status_change *sc, int retVal___ = HPMHooks.source.status.calc_def(bl, sc, def, viewable); } if( HPMHooks.count.HP_status_calc_def_post ) { - defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int *def, bool *viewable); + defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int def, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_def_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &def, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, def, viewable); } } return retVal___; @@ -73940,11 +74391,11 @@ short HP_status_calc_def2(struct block_list *bl, struct status_change *sc, int d int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_status_calc_def2_pre ) { - short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def2, bool *viewable); + short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *def2, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_def2_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &def2, &viewable); + retVal___ = preHookFunc(&bl, &sc, &def2, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73955,10 +74406,10 @@ short HP_status_calc_def2(struct block_list *bl, struct status_change *sc, int d retVal___ = HPMHooks.source.status.calc_def2(bl, sc, def2, viewable); } if( HPMHooks.count.HP_status_calc_def2_post ) { - short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *def2, bool *viewable); + short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int def2, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_def2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &def2, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, def2, viewable); } } return retVal___; @@ -73967,11 +74418,11 @@ defType HP_status_calc_mdef(struct block_list *bl, struct status_change *sc, int int hIndex = 0; defType retVal___ = 0; if( HPMHooks.count.HP_status_calc_mdef_pre ) { - defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef, bool *viewable); + defType (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *mdef, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_mdef_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &mdef, &viewable); + retVal___ = preHookFunc(&bl, &sc, &mdef, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -73982,10 +74433,10 @@ defType HP_status_calc_mdef(struct block_list *bl, struct status_change *sc, int retVal___ = HPMHooks.source.status.calc_mdef(bl, sc, mdef, viewable); } if( HPMHooks.count.HP_status_calc_mdef_post ) { - defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int *mdef, bool *viewable); + defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int mdef, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_mdef_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &mdef, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, mdef, viewable); } } return retVal___; @@ -73994,11 +74445,11 @@ short HP_status_calc_mdef2(struct block_list *bl, struct status_change *sc, int int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_status_calc_mdef2_pre ) { - short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef2, bool *viewable); + short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *mdef2, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_mdef2_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &mdef2, &viewable); + retVal___ = preHookFunc(&bl, &sc, &mdef2, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74009,10 +74460,10 @@ short HP_status_calc_mdef2(struct block_list *bl, struct status_change *sc, int retVal___ = HPMHooks.source.status.calc_mdef2(bl, sc, mdef2, viewable); } if( HPMHooks.count.HP_status_calc_mdef2_post ) { - short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *mdef2, bool *viewable); + short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int mdef2, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_mdef2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &mdef2, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, mdef2, viewable); } } return retVal___; @@ -74021,11 +74472,11 @@ unsigned short HP_status_calc_batk(struct block_list *bl, struct status_change * int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_batk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *batk, bool *viewable); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *batk, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_batk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_batk_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &batk, &viewable); + retVal___ = preHookFunc(&bl, &sc, &batk, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74036,10 +74487,10 @@ unsigned short HP_status_calc_batk(struct block_list *bl, struct status_change * retVal___ = HPMHooks.source.status.calc_batk(bl, sc, batk, viewable); } if( HPMHooks.count.HP_status_calc_batk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *batk, bool *viewable); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int batk, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_batk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_batk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &batk, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, batk, viewable); } } return retVal___; @@ -74048,11 +74499,11 @@ unsigned short HP_status_base_matk(struct block_list *bl, const struct status_da int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_base_matk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, const struct status_data *st, int *level); + unsigned short (*preHookFunc) (struct block_list **bl, const struct status_data **st, int *level); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_base_matk_pre[hIndex].func; - retVal___ = preHookFunc(bl, st, &level); + retVal___ = preHookFunc(&bl, &st, &level); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74063,10 +74514,10 @@ unsigned short HP_status_base_matk(struct block_list *bl, const struct status_da retVal___ = HPMHooks.source.status.base_matk(bl, st, level); } if( HPMHooks.count.HP_status_base_matk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, const struct status_data *st, int *level); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, const struct status_data *st, int level); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_base_matk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, st, &level); + retVal___ = postHookFunc(retVal___, bl, st, level); } } return retVal___; @@ -74075,11 +74526,11 @@ int HP_status_get_weapon_atk(struct block_list *src, struct weapon_atk *watk, in int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_weapon_atk_pre ) { - int (*preHookFunc) (struct block_list *src, struct weapon_atk *watk, int *flag); + int (*preHookFunc) (struct block_list **src, struct weapon_atk **watk, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_weapon_atk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_weapon_atk_pre[hIndex].func; - retVal___ = preHookFunc(src, watk, &flag); + retVal___ = preHookFunc(&src, &watk, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74090,10 +74541,10 @@ int HP_status_get_weapon_atk(struct block_list *src, struct weapon_atk *watk, in retVal___ = HPMHooks.source.status.get_weapon_atk(src, watk, flag); } if( HPMHooks.count.HP_status_get_weapon_atk_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct weapon_atk *watk, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, struct weapon_atk *watk, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_weapon_atk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_get_weapon_atk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, watk, &flag); + retVal___ = postHookFunc(retVal___, src, watk, flag); } } return retVal___; @@ -74102,11 +74553,11 @@ int HP_status_get_total_mdef(struct block_list *src) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_total_mdef_pre ) { - int (*preHookFunc) (struct block_list *src); + int (*preHookFunc) (struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_mdef_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_total_mdef_pre[hIndex].func; - retVal___ = preHookFunc(src); + retVal___ = preHookFunc(&src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74129,11 +74580,11 @@ int HP_status_get_total_def(struct block_list *src) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_total_def_pre ) { - int (*preHookFunc) (struct block_list *src); + int (*preHookFunc) (struct block_list **src); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_def_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_total_def_pre[hIndex].func; - retVal___ = preHookFunc(src); + retVal___ = preHookFunc(&src); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74156,11 +74607,11 @@ int HP_status_get_matk(struct block_list *src, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_get_matk_pre ) { - int (*preHookFunc) (struct block_list *src, int *flag); + int (*preHookFunc) (struct block_list **src, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_matk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_matk_pre[hIndex].func; - retVal___ = preHookFunc(src, &flag); + retVal___ = preHookFunc(&src, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74171,10 +74622,10 @@ int HP_status_get_matk(struct block_list *src, int flag) { retVal___ = HPMHooks.source.status.get_matk(src, flag); } if( HPMHooks.count.HP_status_get_matk_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *src, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_matk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_get_matk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &flag); + retVal___ = postHookFunc(retVal___, src, flag); } } return retVal___; @@ -74182,11 +74633,11 @@ int HP_status_get_matk(struct block_list *src, int flag) { void HP_status_update_matk(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_status_update_matk_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_update_matk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_update_matk_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74288,11 +74739,11 @@ int HP_status_base_amotion_pc(struct map_session_data *sd, struct status_data *s int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_base_amotion_pc_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct status_data *st); + int (*preHookFunc) (struct map_session_data **sd, struct status_data **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_amotion_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_base_amotion_pc_pre[hIndex].func; - retVal___ = preHookFunc(sd, st); + retVal___ = preHookFunc(&sd, &st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74315,11 +74766,11 @@ unsigned short HP_status_base_atk(const struct block_list *bl, const struct stat int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_base_atk_pre ) { - unsigned short (*preHookFunc) (const struct block_list *bl, const struct status_data *st); + unsigned short (*preHookFunc) (const struct block_list **bl, const struct status_data **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_atk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_base_atk_pre[hIndex].func; - retVal___ = preHookFunc(bl, st); + retVal___ = preHookFunc(&bl, &st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74342,11 +74793,11 @@ unsigned int HP_status_get_base_maxhp(const struct map_session_data *sd, const s int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_status_get_base_maxhp_pre ) { - unsigned int (*preHookFunc) (const struct map_session_data *sd, const struct status_data *st); + unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxhp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_base_maxhp_pre[hIndex].func; - retVal___ = preHookFunc(sd, st); + retVal___ = preHookFunc(&sd, &st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74369,11 +74820,11 @@ unsigned int HP_status_get_base_maxsp(const struct map_session_data *sd, const s int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_status_get_base_maxsp_pre ) { - unsigned int (*preHookFunc) (const struct map_session_data *sd, const struct status_data *st); + unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxsp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_get_base_maxsp_pre[hIndex].func; - retVal___ = preHookFunc(sd, st); + retVal___ = preHookFunc(&sd, &st); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74396,11 +74847,11 @@ 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, enum e_status_calc_opt *opt); + int (*preHookFunc) (struct npc_data **nd, enum e_status_calc_opt *opt); *HPMforce_return = false; 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, &opt); + retVal___ = preHookFunc(&nd, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74411,10 +74862,10 @@ int HP_status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) { retVal___ = HPMHooks.source.status.calc_npc_(nd, opt); } if( HPMHooks.count.HP_status_calc_npc__post ) { - int (*postHookFunc) (int retVal___, struct npc_data *nd, enum e_status_calc_opt *opt); + 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, &opt); + retVal___ = postHookFunc(retVal___, nd, opt); } } return retVal___; @@ -74423,11 +74874,11 @@ unsigned short HP_status_calc_str(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_str_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *str); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_str_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_str_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &str); + retVal___ = preHookFunc(&bl, &sc, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74438,10 +74889,10 @@ unsigned short HP_status_calc_str(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_str(bl, sc, str); } if( HPMHooks.count.HP_status_calc_str_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *str); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int str); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_str_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_str_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &str); + retVal___ = postHookFunc(retVal___, bl, sc, str); } } return retVal___; @@ -74450,11 +74901,11 @@ unsigned short HP_status_calc_agi(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_agi_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *agi); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *agi); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_agi_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_agi_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &agi); + retVal___ = preHookFunc(&bl, &sc, &agi); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74465,10 +74916,10 @@ unsigned short HP_status_calc_agi(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_agi(bl, sc, agi); } if( HPMHooks.count.HP_status_calc_agi_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *agi); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int agi); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_agi_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_agi_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &agi); + retVal___ = postHookFunc(retVal___, bl, sc, agi); } } return retVal___; @@ -74477,11 +74928,11 @@ unsigned short HP_status_calc_vit(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_vit_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *vit); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *vit); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_vit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_vit_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &vit); + retVal___ = preHookFunc(&bl, &sc, &vit); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74492,10 +74943,10 @@ unsigned short HP_status_calc_vit(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_vit(bl, sc, vit); } if( HPMHooks.count.HP_status_calc_vit_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *vit); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int vit); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_vit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_vit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &vit); + retVal___ = postHookFunc(retVal___, bl, sc, vit); } } return retVal___; @@ -74504,11 +74955,11 @@ unsigned short HP_status_calc_int(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_int_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *int_); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *int_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_int_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_int_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &int_); + retVal___ = preHookFunc(&bl, &sc, &int_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74519,10 +74970,10 @@ unsigned short HP_status_calc_int(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_int(bl, sc, int_); } if( HPMHooks.count.HP_status_calc_int_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *int_); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int int_); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_int_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_int_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &int_); + retVal___ = postHookFunc(retVal___, bl, sc, int_); } } return retVal___; @@ -74531,11 +74982,11 @@ unsigned short HP_status_calc_dex(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_dex_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dex); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *dex); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dex_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_dex_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &dex); + retVal___ = preHookFunc(&bl, &sc, &dex); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74546,10 +74997,10 @@ unsigned short HP_status_calc_dex(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_dex(bl, sc, dex); } if( HPMHooks.count.HP_status_calc_dex_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *dex); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dex); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dex_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_dex_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &dex); + retVal___ = postHookFunc(retVal___, bl, sc, dex); } } return retVal___; @@ -74558,11 +75009,11 @@ unsigned short HP_status_calc_luk(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_luk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *luk); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *luk); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_luk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_luk_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &luk); + retVal___ = preHookFunc(&bl, &sc, &luk); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74573,10 +75024,10 @@ unsigned short HP_status_calc_luk(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_luk(bl, sc, luk); } if( HPMHooks.count.HP_status_calc_luk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *luk); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int luk); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_luk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_luk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &luk); + retVal___ = postHookFunc(retVal___, bl, sc, luk); } } return retVal___; @@ -74585,11 +75036,11 @@ unsigned short HP_status_calc_watk(struct block_list *bl, struct status_change * int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_watk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *watk, bool *viewable); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *watk, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_watk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_watk_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &watk, &viewable); + retVal___ = preHookFunc(&bl, &sc, &watk, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74600,10 +75051,10 @@ unsigned short HP_status_calc_watk(struct block_list *bl, struct status_change * retVal___ = HPMHooks.source.status.calc_watk(bl, sc, watk, viewable); } if( HPMHooks.count.HP_status_calc_watk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *watk, bool *viewable); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int watk, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_watk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_watk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &watk, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, watk, viewable); } } return retVal___; @@ -74612,11 +75063,11 @@ unsigned short HP_status_calc_matk(struct block_list *bl, struct status_change * int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_matk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *matk, bool *viewable); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *matk, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_matk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_matk_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &matk, &viewable); + retVal___ = preHookFunc(&bl, &sc, &matk, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74627,10 +75078,10 @@ unsigned short HP_status_calc_matk(struct block_list *bl, struct status_change * retVal___ = HPMHooks.source.status.calc_matk(bl, sc, matk, viewable); } if( HPMHooks.count.HP_status_calc_matk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *matk, bool *viewable); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_matk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_matk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &matk, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, matk, viewable); } } return retVal___; @@ -74639,11 +75090,11 @@ signed short HP_status_calc_hit(struct block_list *bl, struct status_change *sc, int hIndex = 0; signed short retVal___ = 0; if( HPMHooks.count.HP_status_calc_hit_pre ) { - signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *hit, bool *viewable); + signed short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *hit, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_hit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_hit_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &hit, &viewable); + retVal___ = preHookFunc(&bl, &sc, &hit, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74654,10 +75105,10 @@ signed short HP_status_calc_hit(struct block_list *bl, struct status_change *sc, retVal___ = HPMHooks.source.status.calc_hit(bl, sc, hit, viewable); } if( HPMHooks.count.HP_status_calc_hit_post ) { - signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *hit, bool *viewable); + signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int hit, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_hit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_hit_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &hit, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, hit, viewable); } } return retVal___; @@ -74666,11 +75117,11 @@ signed short HP_status_calc_critical(struct block_list *bl, struct status_change int hIndex = 0; signed short retVal___ = 0; if( HPMHooks.count.HP_status_calc_critical_pre ) { - signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *critical, bool *viewable); + signed short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *critical, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_critical_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_critical_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &critical, &viewable); + retVal___ = preHookFunc(&bl, &sc, &critical, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74681,10 +75132,10 @@ signed short HP_status_calc_critical(struct block_list *bl, struct status_change retVal___ = HPMHooks.source.status.calc_critical(bl, sc, critical, viewable); } if( HPMHooks.count.HP_status_calc_critical_post ) { - signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *critical, bool *viewable); + signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int critical, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_critical_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_critical_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &critical, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, critical, viewable); } } return retVal___; @@ -74693,11 +75144,11 @@ signed short HP_status_calc_flee(struct block_list *bl, struct status_change *sc int hIndex = 0; signed short retVal___ = 0; if( HPMHooks.count.HP_status_calc_flee_pre ) { - signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee, bool *viewable); + signed short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *flee, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_flee_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &flee, &viewable); + retVal___ = preHookFunc(&bl, &sc, &flee, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74708,10 +75159,10 @@ signed short HP_status_calc_flee(struct block_list *bl, struct status_change *sc retVal___ = HPMHooks.source.status.calc_flee(bl, sc, flee, viewable); } if( HPMHooks.count.HP_status_calc_flee_post ) { - signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *flee, bool *viewable); + signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_flee_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &flee, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, flee, viewable); } } return retVal___; @@ -74720,11 +75171,11 @@ signed short HP_status_calc_flee2(struct block_list *bl, struct status_change *s int hIndex = 0; signed short retVal___ = 0; if( HPMHooks.count.HP_status_calc_flee2_pre ) { - signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee2, bool *viewable); + signed short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *flee2, bool *viewable); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_flee2_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &flee2, &viewable); + retVal___ = preHookFunc(&bl, &sc, &flee2, &viewable); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74735,10 +75186,10 @@ signed short HP_status_calc_flee2(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_flee2(bl, sc, flee2, viewable); } if( HPMHooks.count.HP_status_calc_flee2_post ) { - signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *flee2, bool *viewable); + signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee2, bool viewable); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_flee2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &flee2, &viewable); + retVal___ = postHookFunc(retVal___, bl, sc, flee2, viewable); } } return retVal___; @@ -74747,11 +75198,11 @@ unsigned short HP_status_calc_speed(struct block_list *bl, struct status_change int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_speed_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *speed); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *speed); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_speed_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_speed_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &speed); + retVal___ = preHookFunc(&bl, &sc, &speed); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74762,10 +75213,10 @@ unsigned short HP_status_calc_speed(struct block_list *bl, struct status_change retVal___ = HPMHooks.source.status.calc_speed(bl, sc, speed); } if( HPMHooks.count.HP_status_calc_speed_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *speed); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int speed); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_speed_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_speed_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &speed); + retVal___ = postHookFunc(retVal___, bl, sc, speed); } } return retVal___; @@ -74774,11 +75225,11 @@ short HP_status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_status_calc_aspd_rate_pre ) { - short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd_rate); + short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *aspd_rate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_rate_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_aspd_rate_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &aspd_rate); + retVal___ = preHookFunc(&bl, &sc, &aspd_rate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74789,10 +75240,10 @@ short HP_status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, retVal___ = HPMHooks.source.status.calc_aspd_rate(bl, sc, aspd_rate); } if( HPMHooks.count.HP_status_calc_aspd_rate_post ) { - short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *aspd_rate); + short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd_rate); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_rate_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_aspd_rate_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &aspd_rate); + retVal___ = postHookFunc(retVal___, bl, sc, aspd_rate); } } return retVal___; @@ -74801,11 +75252,11 @@ unsigned short HP_status_calc_dmotion(struct block_list *bl, struct status_chang int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_dmotion_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dmotion); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *dmotion); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dmotion_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_dmotion_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &dmotion); + retVal___ = preHookFunc(&bl, &sc, &dmotion); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74816,10 +75267,10 @@ unsigned short HP_status_calc_dmotion(struct block_list *bl, struct status_chang retVal___ = HPMHooks.source.status.calc_dmotion(bl, sc, dmotion); } if( HPMHooks.count.HP_status_calc_dmotion_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *dmotion); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dmotion); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dmotion_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_dmotion_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &dmotion); + retVal___ = postHookFunc(retVal___, bl, sc, dmotion); } } return retVal___; @@ -74828,11 +75279,11 @@ short HP_status_calc_aspd(struct block_list *bl, struct status_change *sc, short int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_status_calc_aspd_pre ) { - short (*preHookFunc) (struct block_list *bl, struct status_change *sc, short *flag); + short (*preHookFunc) (struct block_list **bl, struct status_change **sc, short *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_aspd_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &flag); + retVal___ = preHookFunc(&bl, &sc, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74843,10 +75294,10 @@ short HP_status_calc_aspd(struct block_list *bl, struct status_change *sc, short retVal___ = HPMHooks.source.status.calc_aspd(bl, sc, flag); } if( HPMHooks.count.HP_status_calc_aspd_post ) { - short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, short *flag); + short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, short flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_aspd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &flag); + retVal___ = postHookFunc(retVal___, bl, sc, flag); } } return retVal___; @@ -74855,11 +75306,11 @@ short HP_status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, i int hIndex = 0; short retVal___ = 0; if( HPMHooks.count.HP_status_calc_fix_aspd_pre ) { - short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd); + short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *aspd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_fix_aspd_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_fix_aspd_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &aspd); + retVal___ = preHookFunc(&bl, &sc, &aspd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74870,10 +75321,10 @@ short HP_status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, i retVal___ = HPMHooks.source.status.calc_fix_aspd(bl, sc, aspd); } if( HPMHooks.count.HP_status_calc_fix_aspd_post ) { - short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *aspd); + short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_fix_aspd_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_fix_aspd_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &aspd); + retVal___ = postHookFunc(retVal___, bl, sc, aspd); } } return retVal___; @@ -74882,11 +75333,11 @@ unsigned int HP_status_calc_maxhp(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_status_calc_maxhp_pre ) { - unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, uint64 *maxhp); + unsigned int (*preHookFunc) (struct block_list **bl, struct status_change **sc, uint64 *maxhp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxhp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_maxhp_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &maxhp); + retVal___ = preHookFunc(&bl, &sc, &maxhp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74897,10 +75348,10 @@ unsigned int HP_status_calc_maxhp(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_maxhp(bl, sc, maxhp); } if( HPMHooks.count.HP_status_calc_maxhp_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, uint64 *maxhp); + unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, uint64 maxhp); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxhp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_maxhp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &maxhp); + retVal___ = postHookFunc(retVal___, bl, sc, maxhp); } } return retVal___; @@ -74909,11 +75360,11 @@ unsigned int HP_status_calc_maxsp(struct block_list *bl, struct status_change *s int hIndex = 0; unsigned int retVal___ = 0; if( HPMHooks.count.HP_status_calc_maxsp_pre ) { - unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, unsigned int *maxsp); + unsigned int (*preHookFunc) (struct block_list **bl, struct status_change **sc, unsigned int *maxsp); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxsp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_maxsp_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &maxsp); + retVal___ = preHookFunc(&bl, &sc, &maxsp); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74924,10 +75375,10 @@ unsigned int HP_status_calc_maxsp(struct block_list *bl, struct status_change *s retVal___ = HPMHooks.source.status.calc_maxsp(bl, sc, maxsp); } if( HPMHooks.count.HP_status_calc_maxsp_post ) { - unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, unsigned int *maxsp); + unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, unsigned int maxsp); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxsp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_maxsp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &maxsp); + retVal___ = postHookFunc(retVal___, bl, sc, maxsp); } } return retVal___; @@ -74936,11 +75387,11 @@ unsigned char HP_status_calc_element(struct block_list *bl, struct status_change int hIndex = 0; unsigned char retVal___ = 0; if( HPMHooks.count.HP_status_calc_element_pre ) { - unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element); + unsigned char (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *element); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_element_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &element); + retVal___ = preHookFunc(&bl, &sc, &element); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74951,10 +75402,10 @@ unsigned char HP_status_calc_element(struct block_list *bl, struct status_change retVal___ = HPMHooks.source.status.calc_element(bl, sc, element); } if( HPMHooks.count.HP_status_calc_element_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *element); + unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_element_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &element); + retVal___ = postHookFunc(retVal___, bl, sc, element); } } return retVal___; @@ -74963,11 +75414,11 @@ unsigned char HP_status_calc_element_lv(struct block_list *bl, struct status_cha int hIndex = 0; unsigned char retVal___ = 0; if( HPMHooks.count.HP_status_calc_element_lv_pre ) { - unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *lv); + unsigned char (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_lv_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_element_lv_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &lv); + retVal___ = preHookFunc(&bl, &sc, &lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -74978,10 +75429,10 @@ unsigned char HP_status_calc_element_lv(struct block_list *bl, struct status_cha retVal___ = HPMHooks.source.status.calc_element_lv(bl, sc, lv); } if( HPMHooks.count.HP_status_calc_element_lv_post ) { - unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *lv); + unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_lv_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_element_lv_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &lv); + retVal___ = postHookFunc(retVal___, bl, sc, lv); } } return retVal___; @@ -74990,11 +75441,11 @@ uint32 HP_status_calc_mode(const struct block_list *bl, const struct status_chan int hIndex = 0; uint32 retVal___ = 0; if( HPMHooks.count.HP_status_calc_mode_pre ) { - uint32 (*preHookFunc) (const struct block_list *bl, const struct status_change *sc, uint32 *mode); + uint32 (*preHookFunc) (const struct block_list **bl, const struct status_change **sc, uint32 *mode); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mode_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_mode_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &mode); + retVal___ = preHookFunc(&bl, &sc, &mode); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75005,10 +75456,10 @@ uint32 HP_status_calc_mode(const struct block_list *bl, const struct status_chan retVal___ = HPMHooks.source.status.calc_mode(bl, sc, mode); } if( HPMHooks.count.HP_status_calc_mode_post ) { - uint32 (*postHookFunc) (uint32 retVal___, const struct block_list *bl, const struct status_change *sc, uint32 *mode); + uint32 (*postHookFunc) (uint32 retVal___, const struct block_list *bl, const struct status_change *sc, uint32 mode); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mode_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_mode_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &mode); + retVal___ = postHookFunc(retVal___, bl, sc, mode); } } return retVal___; @@ -75017,11 +75468,11 @@ unsigned short HP_status_calc_ematk(struct block_list *bl, struct status_change int hIndex = 0; unsigned short retVal___ = 0; if( HPMHooks.count.HP_status_calc_ematk_pre ) { - unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *matk); + unsigned short (*preHookFunc) (struct block_list **bl, struct status_change **sc, int *matk); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_ematk_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_ematk_pre[hIndex].func; - retVal___ = preHookFunc(bl, sc, &matk); + retVal___ = preHookFunc(&bl, &sc, &matk); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75032,10 +75483,10 @@ unsigned short HP_status_calc_ematk(struct block_list *bl, struct status_change retVal___ = HPMHooks.source.status.calc_ematk(bl, sc, matk); } if( HPMHooks.count.HP_status_calc_ematk_post ) { - unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *matk); + unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_ematk_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_ematk_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sc, &matk); + retVal___ = postHookFunc(retVal___, bl, sc, matk); } } return retVal___; @@ -75043,11 +75494,11 @@ unsigned short HP_status_calc_ematk(struct block_list *bl, struct status_change void HP_status_calc_bl_main(struct block_list *bl, int flag) { int hIndex = 0; if( HPMHooks.count.HP_status_calc_bl_main_pre ) { - void (*preHookFunc) (struct block_list *bl, int *flag); + void (*preHookFunc) (struct block_list **bl, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl_main_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_calc_bl_main_pre[hIndex].func; - preHookFunc(bl, &flag); + preHookFunc(&bl, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75058,10 +75509,10 @@ void HP_status_calc_bl_main(struct block_list *bl, int flag) { HPMHooks.source.status.calc_bl_main(bl, flag); } if( HPMHooks.count.HP_status_calc_bl_main_post ) { - void (*postHookFunc) (struct block_list *bl, int *flag); + void (*postHookFunc) (struct block_list *bl, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl_main_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_calc_bl_main_post[hIndex].func; - postHookFunc(bl, &flag); + postHookFunc(bl, flag); } } return; @@ -75069,11 +75520,11 @@ void HP_status_calc_bl_main(struct block_list *bl, int flag) { void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3) { int hIndex = 0; if( HPMHooks.count.HP_status_display_add_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum sc_type *type, int *dval1, int *dval2, int *dval3); + void (*preHookFunc) (struct map_session_data **sd, enum sc_type *type, int *dval1, int *dval2, int *dval3); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_display_add_pre[hIndex].func; - preHookFunc(sd, &type, &dval1, &dval2, &dval3); + preHookFunc(&sd, &type, &dval1, &dval2, &dval3); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75084,10 +75535,10 @@ void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int d HPMHooks.source.status.display_add(sd, type, dval1, dval2, dval3); } if( HPMHooks.count.HP_status_display_add_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum sc_type *type, int *dval1, int *dval2, int *dval3); + void (*postHookFunc) (struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_display_add_post[hIndex].func; - postHookFunc(sd, &type, &dval1, &dval2, &dval3); + postHookFunc(sd, type, dval1, dval2, dval3); } } return; @@ -75095,11 +75546,11 @@ void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int d void HP_status_display_remove(struct map_session_data *sd, enum sc_type type) { int hIndex = 0; if( HPMHooks.count.HP_status_display_remove_pre ) { - void (*preHookFunc) (struct map_session_data *sd, enum sc_type *type); + void (*preHookFunc) (struct map_session_data **sd, enum sc_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_remove_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_display_remove_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75110,10 +75561,10 @@ void HP_status_display_remove(struct map_session_data *sd, enum sc_type type) { HPMHooks.source.status.display_remove(sd, type); } if( HPMHooks.count.HP_status_display_remove_post ) { - void (*postHookFunc) (struct map_session_data *sd, enum sc_type *type); + void (*postHookFunc) (struct map_session_data *sd, enum sc_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_remove_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_display_remove_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -75122,12 +75573,12 @@ int HP_status_natural_heal(struct block_list *bl, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_natural_heal_pre ) { - int (*preHookFunc) (struct block_list *bl, va_list args); + int (*preHookFunc) (struct block_list **bl, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_status_natural_heal_pre[hIndex].func; - retVal___ = preHookFunc(bl, args___copy); + retVal___ = preHookFunc(&bl, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -75170,10 +75621,10 @@ int HP_status_natural_heal_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.status.natural_heal_timer(tid, tick, id, data); } if( HPMHooks.count.HP_status_natural_heal_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_natural_heal_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -75182,11 +75633,11 @@ bool HP_status_readdb_job2(char *fields[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_status_readdb_job2_pre ) { - bool (*preHookFunc) (char *fields[], int *columns, int *current); + bool (*preHookFunc) (char **fields[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_readdb_job2_pre[hIndex].func; - retVal___ = preHookFunc(fields, &columns, ¤t); + retVal___ = preHookFunc(&fields, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75197,10 +75648,10 @@ bool HP_status_readdb_job2(char *fields[], int columns, int current) { retVal___ = HPMHooks.source.status.readdb_job2(fields, columns, current); } if( HPMHooks.count.HP_status_readdb_job2_post ) { - bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_readdb_job2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, fields, &columns, ¤t); + retVal___ = postHookFunc(retVal___, fields, columns, current); } } return retVal___; @@ -75209,11 +75660,11 @@ bool HP_status_readdb_sizefix(char *fields[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_status_readdb_sizefix_pre ) { - bool (*preHookFunc) (char *fields[], int *columns, int *current); + bool (*preHookFunc) (char **fields[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_sizefix_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_readdb_sizefix_pre[hIndex].func; - retVal___ = preHookFunc(fields, &columns, ¤t); + retVal___ = preHookFunc(&fields, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75224,10 +75675,10 @@ bool HP_status_readdb_sizefix(char *fields[], int columns, int current) { retVal___ = HPMHooks.source.status.readdb_sizefix(fields, columns, current); } if( HPMHooks.count.HP_status_readdb_sizefix_post ) { - bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_sizefix_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_readdb_sizefix_post[hIndex].func; - retVal___ = postHookFunc(retVal___, fields, &columns, ¤t); + retVal___ = postHookFunc(retVal___, fields, columns, current); } } return retVal___; @@ -75236,11 +75687,11 @@ int HP_status_readdb_refine_libconfig(const char *filename) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_readdb_refine_libconfig_pre ) { - int (*preHookFunc) (const char *filename); + int (*preHookFunc) (const char **filename); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_pre[hIndex].func; - retVal___ = preHookFunc(filename); + retVal___ = preHookFunc(&filename); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75263,11 +75714,11 @@ int HP_status_readdb_refine_libconfig_sub(struct config_setting_t *r, const char int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_status_readdb_refine_libconfig_sub_pre ) { - int (*preHookFunc) (struct config_setting_t *r, const char *name, const char *source); + int (*preHookFunc) (struct config_setting_t **r, const char **name, const char **source); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_sub_pre[hIndex].func; - retVal___ = preHookFunc(r, name, source); + retVal___ = preHookFunc(&r, &name, &source); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75290,11 +75741,11 @@ bool HP_status_readdb_scconfig(char *fields[], int columns, int current) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_status_readdb_scconfig_pre ) { - bool (*preHookFunc) (char *fields[], int *columns, int *current); + bool (*preHookFunc) (char **fields[], int *columns, int *current); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_scconfig_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_readdb_scconfig_pre[hIndex].func; - retVal___ = preHookFunc(fields, &columns, ¤t); + retVal___ = preHookFunc(&fields, &columns, ¤t); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75305,10 +75756,10 @@ bool HP_status_readdb_scconfig(char *fields[], int columns, int current) { retVal___ = HPMHooks.source.status.readdb_scconfig(fields, columns, current); } if( HPMHooks.count.HP_status_readdb_scconfig_post ) { - bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current); + bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_scconfig_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_readdb_scconfig_post[hIndex].func; - retVal___ = postHookFunc(retVal___, fields, &columns, ¤t); + retVal___ = postHookFunc(retVal___, fields, columns, current); } } return retVal___; @@ -75342,11 +75793,11 @@ void HP_status_read_job_db(void) { void HP_status_read_job_db_sub(int idx, const char *name, struct config_setting_t *jdb) { int hIndex = 0; if( HPMHooks.count.HP_status_read_job_db_sub_pre ) { - void (*preHookFunc) (int *idx, const char *name, struct config_setting_t *jdb); + void (*preHookFunc) (int *idx, const char **name, struct config_setting_t **jdb); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_status_read_job_db_sub_pre[hIndex].func; - preHookFunc(&idx, name, jdb); + preHookFunc(&idx, &name, &jdb); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75357,14 +75808,120 @@ void HP_status_read_job_db_sub(int idx, const char *name, struct config_setting_ HPMHooks.source.status.read_job_db_sub(idx, name, jdb); } if( HPMHooks.count.HP_status_read_job_db_sub_post ) { - void (*postHookFunc) (int *idx, const char *name, struct config_setting_t *jdb); + void (*postHookFunc) (int idx, const char *name, struct config_setting_t *jdb); for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_status_read_job_db_sub_post[hIndex].func; - postHookFunc(&idx, name, jdb); + postHookFunc(idx, name, jdb); } } return; } +void HP_status_set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) { + int hIndex = 0; + if( HPMHooks.count.HP_status_set_sc_pre ) { + void (*preHookFunc) (uint16 *skill_id, sc_type *sc, int *icon, unsigned int *flag); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sc_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_status_set_sc_pre[hIndex].func; + preHookFunc(&skill_id, &sc, &icon, &flag); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.status.set_sc(skill_id, sc, icon, flag); + } + if( HPMHooks.count.HP_status_set_sc_post ) { + void (*postHookFunc) (uint16 skill_id, sc_type sc, int icon, unsigned int flag); + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sc_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_status_set_sc_post[hIndex].func; + postHookFunc(skill_id, sc, icon, flag); + } + } + return; +} +void HP_status_copy(struct status_data *a, const struct status_data *b) { + int hIndex = 0; + if( HPMHooks.count.HP_status_copy_pre ) { + void (*preHookFunc) (struct status_data **a, const struct status_data **b); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_copy_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_status_copy_pre[hIndex].func; + preHookFunc(&a, &b); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.status.copy(a, b); + } + if( HPMHooks.count.HP_status_copy_post ) { + void (*postHookFunc) (struct status_data *a, const struct status_data *b); + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_copy_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_status_copy_post[hIndex].func; + postHookFunc(a, b); + } + } + return; +} +unsigned short HP_status_base_matk_min(const struct status_data *st) { + int hIndex = 0; + unsigned short retVal___ = 0; + if( HPMHooks.count.HP_status_base_matk_min_pre ) { + unsigned short (*preHookFunc) (const struct status_data **st); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_min_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_status_base_matk_min_pre[hIndex].func; + retVal___ = preHookFunc(&st); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.status.base_matk_min(st); + } + if( HPMHooks.count.HP_status_base_matk_min_post ) { + unsigned short (*postHookFunc) (unsigned short retVal___, const struct status_data *st); + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_min_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_status_base_matk_min_post[hIndex].func; + retVal___ = postHookFunc(retVal___, st); + } + } + return retVal___; +} +unsigned short HP_status_base_matk_max(const struct status_data *st) { + int hIndex = 0; + unsigned short retVal___ = 0; + if( HPMHooks.count.HP_status_base_matk_max_pre ) { + unsigned short (*preHookFunc) (const struct status_data **st); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_max_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_status_base_matk_max_pre[hIndex].func; + retVal___ = preHookFunc(&st); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return retVal___; + } + } + { + retVal___ = HPMHooks.source.status.base_matk_max(st); + } + if( HPMHooks.count.HP_status_base_matk_max_post ) { + unsigned short (*postHookFunc) (unsigned short retVal___, const struct status_data *st); + for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_max_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_status_base_matk_max_post[hIndex].func; + retVal___ = postHookFunc(retVal___, st); + } + } + return retVal___; +} /* storage_interface */ void HP_storage_reconnect(void) { int hIndex = 0; @@ -75396,11 +75953,11 @@ int HP_storage_delitem(struct map_session_data *sd, int n, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_delitem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *n, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_delitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_delitem_pre[hIndex].func; - retVal___ = preHookFunc(sd, &n, &amount); + retVal___ = preHookFunc(&sd, &n, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75411,10 +75968,10 @@ int HP_storage_delitem(struct map_session_data *sd, int n, int amount) { retVal___ = HPMHooks.source.storage.delitem(sd, n, amount); } if( HPMHooks.count.HP_storage_delitem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_delitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_delitem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &n, &amount); + retVal___ = postHookFunc(retVal___, sd, n, amount); } } return retVal___; @@ -75423,11 +75980,11 @@ int HP_storage_open(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_open_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_open_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75450,11 +76007,11 @@ int HP_storage_add(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_add_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_add_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_add_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75465,10 +76022,10 @@ int HP_storage_add(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.storage.add(sd, index, amount); } if( HPMHooks.count.HP_storage_add_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -75477,11 +76034,11 @@ int HP_storage_get(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_get_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_get_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_get_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75492,10 +76049,10 @@ int HP_storage_get(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.storage.get(sd, index, amount); } if( HPMHooks.count.HP_storage_get_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_get_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_get_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -75504,11 +76061,11 @@ int HP_storage_additem(struct map_session_data *sd, struct item *item_data, int int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_additem_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount); + int (*preHookFunc) (struct map_session_data **sd, struct item **item_data, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_additem_pre[hIndex].func; - retVal___ = preHookFunc(sd, item_data, &amount); + retVal___ = preHookFunc(&sd, &item_data, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75519,10 +76076,10 @@ int HP_storage_additem(struct map_session_data *sd, struct item *item_data, int retVal___ = HPMHooks.source.storage.additem(sd, item_data, amount); } if( HPMHooks.count.HP_storage_additem_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_additem_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, item_data, &amount); + retVal___ = postHookFunc(retVal___, sd, item_data, amount); } } return retVal___; @@ -75531,11 +76088,11 @@ int HP_storage_addfromcart(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_addfromcart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_addfromcart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_addfromcart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75546,10 +76103,10 @@ int HP_storage_addfromcart(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.storage.addfromcart(sd, index, amount); } if( HPMHooks.count.HP_storage_addfromcart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_addfromcart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_addfromcart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -75558,11 +76115,11 @@ int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_gettocart_pre ) { - int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount); + int (*preHookFunc) (struct map_session_data **sd, int *index, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_gettocart_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_gettocart_pre[hIndex].func; - retVal___ = preHookFunc(sd, &index, &amount); + retVal___ = preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75573,10 +76130,10 @@ int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) { retVal___ = HPMHooks.source.storage.gettocart(sd, index, amount); } if( HPMHooks.count.HP_storage_gettocart_post ) { - int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount); + int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_gettocart_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_gettocart_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &index, &amount); + retVal___ = postHookFunc(retVal___, sd, index, amount); } } return retVal___; @@ -75584,11 +76141,11 @@ int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) { void HP_storage_close(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_storage_close_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_close_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75610,11 +76167,11 @@ void HP_storage_close(struct map_session_data *sd) { void HP_storage_pc_quit(struct map_session_data *sd, int flag) { int hIndex = 0; if( HPMHooks.count.HP_storage_pc_quit_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *flag); + void (*preHookFunc) (struct map_session_data **sd, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_pc_quit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_pc_quit_pre[hIndex].func; - preHookFunc(sd, &flag); + preHookFunc(&sd, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75625,10 +76182,10 @@ void HP_storage_pc_quit(struct map_session_data *sd, int flag) { HPMHooks.source.storage.pc_quit(sd, flag); } if( HPMHooks.count.HP_storage_pc_quit_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *flag); + void (*postHookFunc) (struct map_session_data *sd, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_pc_quit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_pc_quit_post[hIndex].func; - postHookFunc(sd, &flag); + postHookFunc(sd, flag); } } return; @@ -75637,11 +76194,11 @@ int HP_storage_comp_item(const void *i1_, const void *i2_) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_comp_item_pre ) { - int (*preHookFunc) (const void *i1_, const void *i2_); + int (*preHookFunc) (const void **i1_, const void **i2_); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_comp_item_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_comp_item_pre[hIndex].func; - retVal___ = preHookFunc(i1_, i2_); + retVal___ = preHookFunc(&i1_, &i2_); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75663,11 +76220,11 @@ int HP_storage_comp_item(const void *i1_, const void *i2_) { void HP_storage_sortitem(struct item *items, unsigned int size) { int hIndex = 0; if( HPMHooks.count.HP_storage_sortitem_pre ) { - void (*preHookFunc) (struct item *items, unsigned int *size); + void (*preHookFunc) (struct item **items, unsigned int *size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_storage_sortitem_pre[hIndex].func; - preHookFunc(items, &size); + preHookFunc(&items, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75678,10 +76235,10 @@ void HP_storage_sortitem(struct item *items, unsigned int size) { HPMHooks.source.storage.sortitem(items, size); } if( HPMHooks.count.HP_storage_sortitem_post ) { - void (*postHookFunc) (struct item *items, unsigned int *size); + void (*postHookFunc) (struct item *items, unsigned int size); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_storage_sortitem_post[hIndex].func; - postHookFunc(items, &size); + postHookFunc(items, size); } } return; @@ -75690,12 +76247,12 @@ int HP_storage_reconnect_sub(union DBKey key, struct DBData *data, va_list ap) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_storage_reconnect_sub_pre ) { - int (*preHookFunc) (union DBKey *key, struct DBData *data, va_list ap); + int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_sub_pre; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); preHookFunc = HPMHooks.list.HP_storage_reconnect_sub_pre[hIndex].func; - retVal___ = preHookFunc(&key, data, ap___copy); + retVal___ = preHookFunc(&key, &data, ap___copy); va_end(ap___copy); } if( *HPMforce_return ) { @@ -75709,11 +76266,11 @@ int HP_storage_reconnect_sub(union DBKey key, struct DBData *data, va_list ap) { va_end(ap___copy); } if( HPMHooks.count.HP_storage_reconnect_sub_post ) { - int (*postHookFunc) (int retVal___, union DBKey *key, struct DBData *data, va_list ap); + int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap); for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_sub_post; hIndex++ ) { va_list ap___copy; va_copy(ap___copy, ap); postHookFunc = HPMHooks.list.HP_storage_reconnect_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &key, data, ap___copy); + retVal___ = postHookFunc(retVal___, key, data, ap___copy); va_end(ap___copy); } } @@ -75750,11 +76307,11 @@ StringBuf* HP_StrBuf_Malloc(void) { void HP_StrBuf_Init(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Init_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75777,12 +76334,12 @@ int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) { - int (*preHookFunc) (StringBuf *self, const char *fmt, va_list args); + int (*preHookFunc) (StringBuf **self, const char **fmt, va_list args); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) { va_list args___copy; va_copy(args___copy, args); preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func; - retVal___ = preHookFunc(self, fmt, args___copy); + retVal___ = preHookFunc(&self, &fmt, args___copy); va_end(args___copy); } if( *HPMforce_return ) { @@ -75810,11 +76367,11 @@ int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Append_pre ) { - int (*preHookFunc) (StringBuf *self, const StringBuf *sbuf); + int (*preHookFunc) (StringBuf **self, const StringBuf **sbuf); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func; - retVal___ = preHookFunc(self, sbuf); + retVal___ = preHookFunc(&self, &sbuf); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75837,11 +76394,11 @@ int HP_StrBuf_AppendStr(StringBuf *self, const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) { - int (*preHookFunc) (StringBuf *self, const char *str); + int (*preHookFunc) (StringBuf **self, const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func; - retVal___ = preHookFunc(self, str); + retVal___ = preHookFunc(&self, &str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75864,11 +76421,11 @@ int HP_StrBuf_Length(StringBuf *self) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_StrBuf_Length_pre ) { - int (*preHookFunc) (StringBuf *self); + int (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75891,11 +76448,11 @@ char* HP_StrBuf_Value(StringBuf *self) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_StrBuf_Value_pre ) { - char* (*preHookFunc) (StringBuf *self); + char* (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func; - retVal___ = preHookFunc(self); + retVal___ = preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75917,11 +76474,11 @@ char* HP_StrBuf_Value(StringBuf *self) { void HP_StrBuf_Clear(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Clear_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75943,11 +76500,11 @@ void HP_StrBuf_Clear(StringBuf *self) { void HP_StrBuf_Destroy(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Destroy_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75969,11 +76526,11 @@ void HP_StrBuf_Destroy(StringBuf *self) { void HP_StrBuf_Free(StringBuf *self) { int hIndex = 0; if( HPMHooks.count.HP_StrBuf_Free_pre ) { - void (*preHookFunc) (StringBuf *self); + void (*preHookFunc) (StringBuf **self); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func; - preHookFunc(self); + preHookFunc(&self); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -75997,11 +76554,11 @@ char* HP_strlib_jstrescape(char *pt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescape_pre ) { - char* (*preHookFunc) (char *pt); + char* (*preHookFunc) (char **pt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func; - retVal___ = preHookFunc(pt); + retVal___ = preHookFunc(&pt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76024,11 +76581,11 @@ char* HP_strlib_jstrescapecpy(char *pt, const char *spt) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) { - char* (*preHookFunc) (char *pt, const char *spt); + char* (*preHookFunc) (char **pt, const char **spt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt); + retVal___ = preHookFunc(&pt, &spt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76051,11 +76608,11 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) { - int (*preHookFunc) (char *pt, const char *spt, int *size); + int (*preHookFunc) (char **pt, const char **spt, int *size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func; - retVal___ = preHookFunc(pt, spt, &size); + retVal___ = preHookFunc(&pt, &spt, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76066,10 +76623,10 @@ int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) { retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size); } if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) { - int (*postHookFunc) (int retVal___, char *pt, const char *spt, int *size); + int (*postHookFunc) (int retVal___, char *pt, const char *spt, int size); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, pt, spt, &size); + retVal___ = postHookFunc(retVal___, pt, spt, size); } } return retVal___; @@ -76078,11 +76635,11 @@ int HP_strlib_remove_control_chars_(char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) { - int (*preHookFunc) (char *str); + int (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76105,11 +76662,11 @@ char* HP_strlib_trim_(char *str) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_trim__pre ) { - char* (*preHookFunc) (char *str); + char* (*preHookFunc) (char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76132,11 +76689,11 @@ char* HP_strlib_normalize_name_(char *str, const char *delims) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_normalize_name__pre ) { - char* (*preHookFunc) (char *str, const char *delims); + char* (*preHookFunc) (char **str, const char **delims); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func; - retVal___ = preHookFunc(str, delims); + retVal___ = preHookFunc(&str, &delims); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76159,11 +76716,11 @@ const char* HP_strlib_stristr_(const char *haystack, const char *needle) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_stristr__pre ) { - const char* (*preHookFunc) (const char *haystack, const char *needle); + const char* (*preHookFunc) (const char **haystack, const char **needle); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func; - retVal___ = preHookFunc(haystack, needle); + retVal___ = preHookFunc(&haystack, &needle); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76186,11 +76743,11 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_strnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76201,10 +76758,10 @@ size_t HP_strlib_strnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_strnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -76213,11 +76770,11 @@ char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_strtok_r__pre ) { - char* (*preHookFunc) (char *s1, const char *s2, char **lasts); + char* (*preHookFunc) (char **s1, const char **s2, char ***lasts); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func; - retVal___ = preHookFunc(s1, s2, lasts); + retVal___ = preHookFunc(&s1, &s2, &lasts); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76240,11 +76797,11 @@ int HP_strlib_e_mail_check_(char *email) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_e_mail_check__pre ) { - int (*preHookFunc) (char *email); + int (*preHookFunc) (char **email); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func; - retVal___ = preHookFunc(email); + retVal___ = preHookFunc(&email); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76267,11 +76824,11 @@ int HP_strlib_config_switch_(const char *str) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_config_switch__pre ) { - int (*preHookFunc) (const char *str); + int (*preHookFunc) (const char **str); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func; - retVal___ = preHookFunc(str); + retVal___ = preHookFunc(&str); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76294,11 +76851,11 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { int hIndex = 0; char* retVal___ = NULL; if( HPMHooks.count.HP_strlib_safestrncpy__pre ) { - char* (*preHookFunc) (char *dst, const char *src, size_t *n); + char* (*preHookFunc) (char **dst, const char **src, size_t *n); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func; - retVal___ = preHookFunc(dst, src, &n); + retVal___ = preHookFunc(&dst, &src, &n); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76309,10 +76866,10 @@ char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) { retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n); } if( HPMHooks.count.HP_strlib_safestrncpy__post ) { - char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t *n); + char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t n); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func; - retVal___ = postHookFunc(retVal___, dst, src, &n); + retVal___ = postHookFunc(retVal___, dst, src, n); } } return retVal___; @@ -76321,11 +76878,11 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_strlib_safestrnlen__pre ) { - size_t (*preHookFunc) (const char *string, size_t *maxlen); + size_t (*preHookFunc) (const char **string, size_t *maxlen); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func; - retVal___ = preHookFunc(string, &maxlen); + retVal___ = preHookFunc(&string, &maxlen); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76336,10 +76893,10 @@ size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) { retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen); } if( HPMHooks.count.HP_strlib_safestrnlen__post ) { - size_t (*postHookFunc) (size_t retVal___, const char *string, size_t *maxlen); + size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func; - retVal___ = postHookFunc(retVal___, string, &maxlen); + retVal___ = postHookFunc(retVal___, string, maxlen); } } return retVal___; @@ -76348,11 +76905,11 @@ int HP_strlib_strline_(const char *str, size_t pos) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_strlib_strline__pre ) { - int (*preHookFunc) (const char *str, size_t *pos); + int (*preHookFunc) (const char **str, size_t *pos); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func; - retVal___ = preHookFunc(str, &pos); + retVal___ = preHookFunc(&str, &pos); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76363,10 +76920,10 @@ int HP_strlib_strline_(const char *str, size_t pos) { retVal___ = HPMHooks.source.strlib.strline_(str, pos); } if( HPMHooks.count.HP_strlib_strline__post ) { - int (*postHookFunc) (int retVal___, const char *str, size_t *pos); + int (*postHookFunc) (int retVal___, const char *str, size_t pos); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &pos); + retVal___ = postHookFunc(retVal___, str, pos); } } return retVal___; @@ -76375,11 +76932,11 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_strlib_bin2hex__pre ) { - bool (*preHookFunc) (char *output, const unsigned char *input, size_t *count); + bool (*preHookFunc) (char **output, const unsigned char **input, size_t *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func; - retVal___ = preHookFunc(output, input, &count); + retVal___ = preHookFunc(&output, &input, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76390,10 +76947,10 @@ bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count); } if( HPMHooks.count.HP_strlib_bin2hex__post ) { - bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t *count); + bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t count); for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func; - retVal___ = postHookFunc(retVal___, output, input, &count); + retVal___ = postHookFunc(retVal___, output, input, count); } } return retVal___; @@ -76403,11 +76960,11 @@ int HP_sv_parse_next(struct s_svstate *svstate) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_next_pre ) { - int (*preHookFunc) (struct s_svstate *svstate); + int (*preHookFunc) (struct s_svstate **svstate); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func; - retVal___ = preHookFunc(svstate); + retVal___ = preHookFunc(&svstate); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76430,11 +76987,11 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_parse_pre ) { - int (*preHookFunc) (const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*preHookFunc) (const char **str, int *len, int *startoff, char *delim, int **out_pos, int *npos, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_pos, &npos, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76445,10 +77002,10 @@ int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt); } if( HPMHooks.count.HP_sv_parse_post ) { - int (*postHookFunc) (int retVal___, const char *str, int *len, int *startoff, char *delim, int *out_pos, int *npos, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_pos, &npos, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_pos, npos, opt); } } return retVal___; @@ -76457,11 +77014,11 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_sv_split_pre ) { - int (*preHookFunc) (char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*preHookFunc) (char **str, int *len, int *startoff, char *delim, char ***out_fields, int *nfields, enum e_svopt *opt); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func; - retVal___ = preHookFunc(str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_fields, &nfields, &opt); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76472,10 +77029,10 @@ int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt); } if( HPMHooks.count.HP_sv_split_post ) { - int (*postHookFunc) (int retVal___, char *str, int *len, int *startoff, char *delim, char **out_fields, int *nfields, enum e_svopt *opt); + int (*postHookFunc) (int retVal___, char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func; - retVal___ = postHookFunc(retVal___, str, &len, &startoff, &delim, out_fields, &nfields, &opt); + retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_fields, nfields, opt); } } return retVal___; @@ -76484,11 +77041,11 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_escape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len, const char **escapes); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len, escapes); + retVal___ = preHookFunc(&out_dest, &src, &len, &escapes); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76499,10 +77056,10 @@ size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *e retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes); } if( HPMHooks.count.HP_sv_escape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len, const char *escapes); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len, const char *escapes); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len, escapes); + retVal___ = postHookFunc(retVal___, out_dest, src, len, escapes); } } return retVal___; @@ -76511,11 +77068,11 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { int hIndex = 0; size_t retVal___ = 0; if( HPMHooks.count.HP_sv_unescape_c_pre ) { - size_t (*preHookFunc) (char *out_dest, const char *src, size_t *len); + size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func; - retVal___ = preHookFunc(out_dest, src, &len); + retVal___ = preHookFunc(&out_dest, &src, &len); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76526,10 +77083,10 @@ size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) { retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len); } if( HPMHooks.count.HP_sv_unescape_c_post ) { - size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t *len); + size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func; - retVal___ = postHookFunc(retVal___, out_dest, src, &len); + retVal___ = postHookFunc(retVal___, out_dest, src, len); } } return retVal___; @@ -76538,11 +77095,11 @@ const char* HP_sv_skip_escaped_c(const char *p) { int hIndex = 0; const char* retVal___ = NULL; if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) { - const char* (*preHookFunc) (const char *p); + const char* (*preHookFunc) (const char **p); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func; - retVal___ = preHookFunc(p); + retVal___ = preHookFunc(&p); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76565,11 +77122,11 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_sv_readdb_pre ) { - bool (*preHookFunc) (const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*preHookFunc) (const char **directory, const char **filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( **parseproc ) (char *fields[], int columns, int current)); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func; - retVal___ = preHookFunc(directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = preHookFunc(&directory, &filename, &delim, &mincols, &maxcols, &maxrows, &parseproc); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -76580,10 +77137,10 @@ bool HP_sv_readdb(const char *directory, const char *filename, char delim, int m retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc); } if( HPMHooks.count.HP_sv_readdb_post ) { - bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); + bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)); for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func; - retVal___ = postHookFunc(retVal___, directory, filename, &delim, &mincols, &maxcols, &maxrows, parseproc); + retVal___ = postHookFunc(retVal___, directory, filename, delim, mincols, maxcols, maxrows, parseproc); } } return retVal___; @@ -77146,10 +77703,10 @@ int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) { retVal___ = HPMHooks.source.timer.add(tick, func, id, data); } if( HPMHooks.count.HP_timer_add_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data); + retVal___ = postHookFunc(retVal___, tick, func, id, data); } } return retVal___; @@ -77173,10 +77730,10 @@ int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval); } if( HPMHooks.count.HP_timer_add_interval_post ) { - int (*postHookFunc) (int retVal___, int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval); + int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data, int interval); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick, &func, &id, &data, &interval); + retVal___ = postHookFunc(retVal___, tick, func, id, data, interval); } } return retVal___; @@ -77200,10 +77757,10 @@ const struct TimerData* HP_timer_get(int tid) { retVal___ = HPMHooks.source.timer.get(tid); } if( HPMHooks.count.HP_timer_get_post ) { - const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int *tid); + const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int tid); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid); + retVal___ = postHookFunc(retVal___, tid); } } return retVal___; @@ -77227,10 +77784,10 @@ int HP_timer_delete(int tid, TimerFunc func) { retVal___ = HPMHooks.source.timer.delete(tid, func); } if( HPMHooks.count.HP_timer_delete_post ) { - int (*postHookFunc) (int retVal___, int *tid, TimerFunc *func); + int (*postHookFunc) (int retVal___, int tid, TimerFunc func); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &func); + retVal___ = postHookFunc(retVal___, tid, func); } } return retVal___; @@ -77254,10 +77811,10 @@ int64 HP_timer_addtick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.addtick(tid, tick); } if( HPMHooks.count.HP_timer_addtick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -77281,10 +77838,10 @@ int64 HP_timer_settick(int tid, int64 tick) { retVal___ = HPMHooks.source.timer.settick(tid, tick); } if( HPMHooks.count.HP_timer_settick_post ) { - int64 (*postHookFunc) (int64 retVal___, int *tid, int64 *tick); + int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick); + retVal___ = postHookFunc(retVal___, tid, tick); } } return retVal___; @@ -77293,11 +77850,11 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_timer_add_func_list_pre ) { - int (*preHookFunc) (TimerFunc *func, char *name); + int (*preHookFunc) (TimerFunc *func, char **name); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func; - retVal___ = preHookFunc(&func, name); + retVal___ = preHookFunc(&func, &name); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77308,10 +77865,10 @@ int HP_timer_add_func_list(TimerFunc func, char *name) { retVal___ = HPMHooks.source.timer.add_func_list(func, name); } if( HPMHooks.count.HP_timer_add_func_list_post ) { - int (*postHookFunc) (int retVal___, TimerFunc *func, char *name); + int (*postHookFunc) (int retVal___, TimerFunc func, char *name); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &func, name); + retVal___ = postHookFunc(retVal___, func, name); } } return retVal___; @@ -77362,10 +77919,10 @@ int HP_timer_perform(int64 tick) { retVal___ = HPMHooks.source.timer.perform(tick); } if( HPMHooks.count.HP_timer_perform_post ) { - int (*postHookFunc) (int retVal___, int64 *tick); + int (*postHookFunc) (int retVal___, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tick); + retVal___ = postHookFunc(retVal___, tick); } } return retVal___; @@ -77426,11 +77983,11 @@ void HP_timer_final(void) { void HP_trade_request(struct map_session_data *sd, struct map_session_data *target_sd) { int hIndex = 0; if( HPMHooks.count.HP_trade_request_pre ) { - void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *target_sd); + void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **target_sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_request_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_request_pre[hIndex].func; - preHookFunc(sd, target_sd); + preHookFunc(&sd, &target_sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77452,11 +78009,11 @@ void HP_trade_request(struct map_session_data *sd, struct map_session_data *targ void HP_trade_ack(struct map_session_data *sd, int type) { int hIndex = 0; if( HPMHooks.count.HP_trade_ack_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *type); + void (*preHookFunc) (struct map_session_data **sd, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_ack_pre[hIndex].func; - preHookFunc(sd, &type); + preHookFunc(&sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77467,10 +78024,10 @@ void HP_trade_ack(struct map_session_data *sd, int type) { HPMHooks.source.trade.ack(sd, type); } if( HPMHooks.count.HP_trade_ack_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *type); + void (*postHookFunc) (struct map_session_data *sd, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_trade_ack_post[hIndex].func; - postHookFunc(sd, &type); + postHookFunc(sd, type); } } return; @@ -77479,11 +78036,11 @@ int HP_trade_check_impossible(struct map_session_data *sd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_trade_check_impossible_pre ) { - int (*preHookFunc) (struct map_session_data *sd); + int (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_impossible_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_check_impossible_pre[hIndex].func; - retVal___ = preHookFunc(sd); + retVal___ = preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77506,11 +78063,11 @@ int HP_trade_check(struct map_session_data *sd, struct map_session_data *tsd) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_trade_check_pre ) { - int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd); + int (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_check_pre[hIndex].func; - retVal___ = preHookFunc(sd, tsd); + retVal___ = preHookFunc(&sd, &tsd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77532,11 +78089,11 @@ int HP_trade_check(struct map_session_data *sd, struct map_session_data *tsd) { void HP_trade_additem(struct map_session_data *sd, short index, short amount) { int hIndex = 0; if( HPMHooks.count.HP_trade_additem_pre ) { - void (*preHookFunc) (struct map_session_data *sd, short *index, short *amount); + void (*preHookFunc) (struct map_session_data **sd, short *index, short *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_additem_pre[hIndex].func; - preHookFunc(sd, &index, &amount); + preHookFunc(&sd, &index, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77547,10 +78104,10 @@ void HP_trade_additem(struct map_session_data *sd, short index, short amount) { HPMHooks.source.trade.additem(sd, index, amount); } if( HPMHooks.count.HP_trade_additem_post ) { - void (*postHookFunc) (struct map_session_data *sd, short *index, short *amount); + void (*postHookFunc) (struct map_session_data *sd, short index, short amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_trade_additem_post[hIndex].func; - postHookFunc(sd, &index, &amount); + postHookFunc(sd, index, amount); } } return; @@ -77558,11 +78115,11 @@ void HP_trade_additem(struct map_session_data *sd, short index, short amount) { void HP_trade_addzeny(struct map_session_data *sd, int amount) { int hIndex = 0; if( HPMHooks.count.HP_trade_addzeny_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *amount); + void (*preHookFunc) (struct map_session_data **sd, int *amount); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_addzeny_pre[hIndex].func; - preHookFunc(sd, &amount); + preHookFunc(&sd, &amount); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77573,10 +78130,10 @@ void HP_trade_addzeny(struct map_session_data *sd, int amount) { HPMHooks.source.trade.addzeny(sd, amount); } if( HPMHooks.count.HP_trade_addzeny_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *amount); + void (*postHookFunc) (struct map_session_data *sd, int amount); for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_trade_addzeny_post[hIndex].func; - postHookFunc(sd, &amount); + postHookFunc(sd, amount); } } return; @@ -77584,11 +78141,11 @@ void HP_trade_addzeny(struct map_session_data *sd, int amount) { void HP_trade_ok(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_trade_ok_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ok_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_ok_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77610,11 +78167,11 @@ void HP_trade_ok(struct map_session_data *sd) { void HP_trade_cancel(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_trade_cancel_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_cancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_cancel_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77636,11 +78193,11 @@ void HP_trade_cancel(struct map_session_data *sd) { void HP_trade_commit(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_trade_commit_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_commit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_trade_commit_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77679,10 +78236,10 @@ int HP_unit_init(bool minimal) { retVal___ = HPMHooks.source.unit.init(minimal); } if( HPMHooks.count.HP_unit_init_post ) { - int (*postHookFunc) (int retVal___, bool *minimal); + 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___, &minimal); + retVal___ = postHookFunc(retVal___, minimal); } } return retVal___; @@ -77718,11 +78275,11 @@ struct unit_data* HP_unit_bl2ud(struct block_list *bl) { int hIndex = 0; struct unit_data* retVal___ = NULL; if( HPMHooks.count.HP_unit_bl2ud_pre ) { - struct unit_data* (*preHookFunc) (struct block_list *bl); + struct unit_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_bl2ud_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77745,11 +78302,11 @@ struct unit_data* HP_unit_bl2ud2(struct block_list *bl) { int hIndex = 0; struct unit_data* retVal___ = NULL; if( HPMHooks.count.HP_unit_bl2ud2_pre ) { - struct unit_data* (*preHookFunc) (struct block_list *bl); + struct unit_data* (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_bl2ud2_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77768,6 +78325,32 @@ struct unit_data* HP_unit_bl2ud2(struct block_list *bl) { } return retVal___; } +void HP_unit_init_ud(struct unit_data *ud) { + int hIndex = 0; + if( HPMHooks.count.HP_unit_init_ud_pre ) { + void (*preHookFunc) (struct unit_data **ud); + *HPMforce_return = false; + for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_ud_pre; hIndex++ ) { + preHookFunc = HPMHooks.list.HP_unit_init_ud_pre[hIndex].func; + preHookFunc(&ud); + } + if( *HPMforce_return ) { + *HPMforce_return = false; + return; + } + } + { + HPMHooks.source.unit.init_ud(ud); + } + if( HPMHooks.count.HP_unit_init_ud_post ) { + void (*postHookFunc) (struct unit_data *ud); + for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_ud_post; hIndex++ ) { + postHookFunc = HPMHooks.list.HP_unit_init_ud_post[hIndex].func; + postHookFunc(ud); + } + } + return; +} int HP_unit_attack_timer(int tid, int64 tick, int id, intptr_t data) { int hIndex = 0; int retVal___ = 0; @@ -77787,10 +78370,10 @@ int HP_unit_attack_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.attack_timer(tid, tick, id, data); } if( HPMHooks.count.HP_unit_attack_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_attack_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -77814,10 +78397,10 @@ int HP_unit_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.walktoxy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_unit_walktoxy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_walktoxy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -77826,11 +78409,11 @@ int HP_unit_walktoxy_sub(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_walktoxy_sub_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_walktoxy_sub_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77868,10 +78451,10 @@ int HP_unit_delay_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.delay_walktoxy_timer(tid, tick, id, data); } if( HPMHooks.count.HP_unit_delay_walktoxy_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_delay_walktoxy_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_delay_walktoxy_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -77880,11 +78463,11 @@ int HP_unit_walktoxy(struct block_list *bl, short x, short y, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_walktoxy_pre ) { - int (*preHookFunc) (struct block_list *bl, short *x, short *y, int *flag); + int (*preHookFunc) (struct block_list **bl, short *x, short *y, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_walktoxy_pre[hIndex].func; - retVal___ = preHookFunc(bl, &x, &y, &flag); + retVal___ = preHookFunc(&bl, &x, &y, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77895,10 +78478,10 @@ int HP_unit_walktoxy(struct block_list *bl, short x, short y, int flag) { retVal___ = HPMHooks.source.unit.walktoxy(bl, x, y, flag); } if( HPMHooks.count.HP_unit_walktoxy_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, short *x, short *y, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, short x, short y, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_walktoxy_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &x, &y, &flag); + retVal___ = postHookFunc(retVal___, bl, x, y, flag); } } return retVal___; @@ -77922,10 +78505,10 @@ int HP_unit_walktobl_sub(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.walktobl_sub(tid, tick, id, data); } if( HPMHooks.count.HP_unit_walktobl_sub_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_walktobl_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -77934,11 +78517,11 @@ int HP_unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, i int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_walktobl_pre ) { - int (*preHookFunc) (struct block_list *bl, struct block_list *tbl, int *range, int *flag); + int (*preHookFunc) (struct block_list **bl, struct block_list **tbl, int *range, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_walktobl_pre[hIndex].func; - retVal___ = preHookFunc(bl, tbl, &range, &flag); + retVal___ = preHookFunc(&bl, &tbl, &range, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77949,10 +78532,10 @@ int HP_unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, i retVal___ = HPMHooks.source.unit.walktobl(bl, tbl, range, flag); } if( HPMHooks.count.HP_unit_walktobl_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *tbl, int *range, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *tbl, int range, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_walktobl_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, tbl, &range, &flag); + retVal___ = postHookFunc(retVal___, bl, tbl, range, flag); } } return retVal___; @@ -77961,11 +78544,11 @@ bool HP_unit_run(struct block_list *bl, struct map_session_data *sd, enum sc_typ int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_unit_run_pre ) { - bool (*preHookFunc) (struct block_list *bl, struct map_session_data *sd, enum sc_type *type); + bool (*preHookFunc) (struct block_list **bl, struct map_session_data **sd, enum sc_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_run_pre[hIndex].func; - retVal___ = preHookFunc(bl, sd, &type); + retVal___ = preHookFunc(&bl, &sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -77976,10 +78559,10 @@ bool HP_unit_run(struct block_list *bl, struct map_session_data *sd, enum sc_typ retVal___ = HPMHooks.source.unit.run(bl, sd, type); } if( HPMHooks.count.HP_unit_run_post ) { - bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct map_session_data *sd, enum sc_type *type); + bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct map_session_data *sd, enum sc_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_run_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, sd, &type); + retVal___ = postHookFunc(retVal___, bl, sd, type); } } return retVal___; @@ -77987,11 +78570,11 @@ bool HP_unit_run(struct block_list *bl, struct map_session_data *sd, enum sc_typ void HP_unit_run_hit(struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type type) { int hIndex = 0; if( HPMHooks.count.HP_unit_run_hit_pre ) { - void (*preHookFunc) (struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type *type); + void (*preHookFunc) (struct block_list **bl, struct status_change **sc, struct map_session_data **sd, enum sc_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_hit_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_run_hit_pre[hIndex].func; - preHookFunc(bl, sc, sd, &type); + preHookFunc(&bl, &sc, &sd, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78002,10 +78585,10 @@ void HP_unit_run_hit(struct block_list *bl, struct status_change *sc, struct map HPMHooks.source.unit.run_hit(bl, sc, sd, type); } if( HPMHooks.count.HP_unit_run_hit_post ) { - void (*postHookFunc) (struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type *type); + void (*postHookFunc) (struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_hit_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_run_hit_post[hIndex].func; - postHookFunc(bl, sc, sd, &type); + postHookFunc(bl, sc, sd, type); } } return; @@ -78014,11 +78597,11 @@ int HP_unit_escape(struct block_list *bl, struct block_list *target, short dist) int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_escape_pre ) { - int (*preHookFunc) (struct block_list *bl, struct block_list *target, short *dist); + int (*preHookFunc) (struct block_list **bl, struct block_list **target, short *dist); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_escape_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_escape_pre[hIndex].func; - retVal___ = preHookFunc(bl, target, &dist); + retVal___ = preHookFunc(&bl, &target, &dist); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78029,10 +78612,10 @@ int HP_unit_escape(struct block_list *bl, struct block_list *target, short dist) retVal___ = HPMHooks.source.unit.escape(bl, target, dist); } if( HPMHooks.count.HP_unit_escape_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *target, short *dist); + int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *target, short dist); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_escape_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_escape_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, target, &dist); + retVal___ = postHookFunc(retVal___, bl, target, dist); } } return retVal___; @@ -78041,11 +78624,11 @@ int HP_unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, b int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_movepos_pre ) { - int (*preHookFunc) (struct block_list *bl, short *dst_x, short *dst_y, int *easy, bool *checkpath); + int (*preHookFunc) (struct block_list **bl, short *dst_x, short *dst_y, int *easy, bool *checkpath); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_movepos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_movepos_pre[hIndex].func; - retVal___ = preHookFunc(bl, &dst_x, &dst_y, &easy, &checkpath); + retVal___ = preHookFunc(&bl, &dst_x, &dst_y, &easy, &checkpath); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78056,10 +78639,10 @@ int HP_unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, b retVal___ = HPMHooks.source.unit.movepos(bl, dst_x, dst_y, easy, checkpath); } if( HPMHooks.count.HP_unit_movepos_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, short *dst_x, short *dst_y, int *easy, bool *checkpath); + int (*postHookFunc) (int retVal___, struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_movepos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_movepos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &dst_x, &dst_y, &easy, &checkpath); + retVal___ = postHookFunc(retVal___, bl, dst_x, dst_y, easy, checkpath); } } return retVal___; @@ -78068,11 +78651,11 @@ int HP_unit_setdir(struct block_list *bl, unsigned char dir) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_setdir_pre ) { - int (*preHookFunc) (struct block_list *bl, unsigned char *dir); + int (*preHookFunc) (struct block_list **bl, unsigned char *dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_setdir_pre[hIndex].func; - retVal___ = preHookFunc(bl, &dir); + retVal___ = preHookFunc(&bl, &dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78083,10 +78666,10 @@ int HP_unit_setdir(struct block_list *bl, unsigned char dir) { retVal___ = HPMHooks.source.unit.setdir(bl, dir); } if( HPMHooks.count.HP_unit_setdir_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char *dir); + int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char dir); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_setdir_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &dir); + retVal___ = postHookFunc(retVal___, bl, dir); } } return retVal___; @@ -78095,11 +78678,11 @@ uint8 HP_unit_getdir(struct block_list *bl) { int hIndex = 0; uint8 retVal___ = 0; if( HPMHooks.count.HP_unit_getdir_pre ) { - uint8 (*preHookFunc) (struct block_list *bl); + uint8 (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_getdir_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_getdir_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78122,11 +78705,11 @@ int HP_unit_blown(struct block_list *bl, int dx, int dy, int count, int flag) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_blown_pre ) { - int (*preHookFunc) (struct block_list *bl, int *dx, int *dy, int *count, int *flag); + int (*preHookFunc) (struct block_list **bl, int *dx, int *dy, int *count, int *flag); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_blown_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_blown_pre[hIndex].func; - retVal___ = preHookFunc(bl, &dx, &dy, &count, &flag); + retVal___ = preHookFunc(&bl, &dx, &dy, &count, &flag); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78137,10 +78720,10 @@ int HP_unit_blown(struct block_list *bl, int dx, int dy, int count, int flag) { retVal___ = HPMHooks.source.unit.blown(bl, dx, dy, count, flag); } if( HPMHooks.count.HP_unit_blown_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *dx, int *dy, int *count, int *flag); + int (*postHookFunc) (int retVal___, struct block_list *bl, int dx, int dy, int count, int flag); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_blown_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_blown_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &dx, &dy, &count, &flag); + retVal___ = postHookFunc(retVal___, bl, dx, dy, count, flag); } } return retVal___; @@ -78149,11 +78732,11 @@ int HP_unit_warp(struct block_list *bl, short m, short x, short y, clr_type type int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_warp_pre ) { - int (*preHookFunc) (struct block_list *bl, short *m, short *x, short *y, clr_type *type); + int (*preHookFunc) (struct block_list **bl, short *m, short *x, short *y, clr_type *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_warp_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_warp_pre[hIndex].func; - retVal___ = preHookFunc(bl, &m, &x, &y, &type); + retVal___ = preHookFunc(&bl, &m, &x, &y, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78164,10 +78747,10 @@ int HP_unit_warp(struct block_list *bl, short m, short x, short y, clr_type type retVal___ = HPMHooks.source.unit.warp(bl, m, x, y, type); } if( HPMHooks.count.HP_unit_warp_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, short *m, short *x, short *y, clr_type *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, short m, short x, short y, clr_type type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_warp_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_warp_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &m, &x, &y, &type); + retVal___ = postHookFunc(retVal___, bl, m, x, y, type); } } return retVal___; @@ -78176,11 +78759,11 @@ int HP_unit_stop_walking(struct block_list *bl, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_stop_walking_pre ) { - int (*preHookFunc) (struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_walking_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_stop_walking_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type); + retVal___ = preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78191,10 +78774,10 @@ int HP_unit_stop_walking(struct block_list *bl, int type) { retVal___ = HPMHooks.source.unit.stop_walking(bl, type); } if( HPMHooks.count.HP_unit_stop_walking_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_walking_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_stop_walking_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type); + retVal___ = postHookFunc(retVal___, bl, type); } } return retVal___; @@ -78203,11 +78786,11 @@ int HP_unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_skilluse_id_pre ) { - int (*preHookFunc) (struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **src, int *target_id, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_skilluse_id_pre[hIndex].func; - retVal___ = preHookFunc(src, &target_id, &skill_id, &skill_lv); + retVal___ = preHookFunc(&src, &target_id, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78218,10 +78801,10 @@ int HP_unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, retVal___ = HPMHooks.source.unit.skilluse_id(src, target_id, skill_id, skill_lv); } if( HPMHooks.count.HP_unit_skilluse_id_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_skilluse_id_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &target_id, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, src, target_id, skill_id, skill_lv); } } return retVal___; @@ -78245,10 +78828,10 @@ int HP_unit_step_timer(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.step_timer(tid, tick, id, data); } if( HPMHooks.count.HP_unit_step_timer_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_step_timer_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_step_timer_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -78256,11 +78839,11 @@ int HP_unit_step_timer(int tid, int64 tick, int id, intptr_t data) { void HP_unit_stop_stepaction(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_unit_stop_stepaction_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_stepaction_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_stop_stepaction_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78283,11 +78866,11 @@ int HP_unit_is_walking(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_is_walking_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_is_walking_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_is_walking_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78310,11 +78893,11 @@ int HP_unit_can_move(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_can_move_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_move_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_can_move_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78352,10 +78935,10 @@ int HP_unit_resume_running(int tid, int64 tick, int id, intptr_t data) { retVal___ = HPMHooks.source.unit.resume_running(tid, tick, id, data); } if( HPMHooks.count.HP_unit_resume_running_post ) { - int (*postHookFunc) (int retVal___, int *tid, int64 *tick, int *id, intptr_t *data); + int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_resume_running_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_resume_running_post[hIndex].func; - retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data); + retVal___ = postHookFunc(retVal___, tid, tick, id, data); } } return retVal___; @@ -78364,11 +78947,11 @@ int HP_unit_set_walkdelay(struct block_list *bl, int64 tick, int delay, int type int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_set_walkdelay_pre ) { - int (*preHookFunc) (struct block_list *bl, int64 *tick, int *delay, int *type); + int (*preHookFunc) (struct block_list **bl, int64 *tick, int *delay, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_walkdelay_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_set_walkdelay_pre[hIndex].func; - retVal___ = preHookFunc(bl, &tick, &delay, &type); + retVal___ = preHookFunc(&bl, &tick, &delay, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78379,10 +78962,10 @@ int HP_unit_set_walkdelay(struct block_list *bl, int64 tick, int delay, int type retVal___ = HPMHooks.source.unit.set_walkdelay(bl, tick, delay, type); } if( HPMHooks.count.HP_unit_set_walkdelay_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *tick, int *delay, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int64 tick, int delay, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_walkdelay_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_set_walkdelay_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &tick, &delay, &type); + retVal___ = postHookFunc(retVal___, bl, tick, delay, type); } } return retVal___; @@ -78391,11 +78974,11 @@ int HP_unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_skilluse_id2_pre ) { - int (*preHookFunc) (struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); + int (*preHookFunc) (struct block_list **src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_skilluse_id2_pre[hIndex].func; - retVal___ = preHookFunc(src, &target_id, &skill_id, &skill_lv, &casttime, &castcancel); + retVal___ = preHookFunc(&src, &target_id, &skill_id, &skill_lv, &casttime, &castcancel); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78406,10 +78989,10 @@ int HP_unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, retVal___ = HPMHooks.source.unit.skilluse_id2(src, target_id, skill_id, skill_lv, casttime, castcancel); } if( HPMHooks.count.HP_unit_skilluse_id2_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); + int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_skilluse_id2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &target_id, &skill_id, &skill_lv, &casttime, &castcancel); + retVal___ = postHookFunc(retVal___, src, target_id, skill_id, skill_lv, casttime, castcancel); } } return retVal___; @@ -78418,11 +79001,11 @@ int HP_unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, u int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_skilluse_pos_pre ) { - int (*preHookFunc) (struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv); + int (*preHookFunc) (struct block_list **src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_skilluse_pos_pre[hIndex].func; - retVal___ = preHookFunc(src, &skill_x, &skill_y, &skill_id, &skill_lv); + retVal___ = preHookFunc(&src, &skill_x, &skill_y, &skill_id, &skill_lv); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78433,10 +79016,10 @@ int HP_unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, u retVal___ = HPMHooks.source.unit.skilluse_pos(src, skill_x, skill_y, skill_id, skill_lv); } if( HPMHooks.count.HP_unit_skilluse_pos_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv); + int (*postHookFunc) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_skilluse_pos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &skill_x, &skill_y, &skill_id, &skill_lv); + retVal___ = postHookFunc(retVal___, src, skill_x, skill_y, skill_id, skill_lv); } } return retVal___; @@ -78445,11 +79028,11 @@ int HP_unit_skilluse_pos2(struct block_list *src, short skill_x, short skill_y, int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_skilluse_pos2_pre ) { - int (*preHookFunc) (struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); + int (*preHookFunc) (struct block_list **src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos2_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_skilluse_pos2_pre[hIndex].func; - retVal___ = preHookFunc(src, &skill_x, &skill_y, &skill_id, &skill_lv, &casttime, &castcancel); + retVal___ = preHookFunc(&src, &skill_x, &skill_y, &skill_id, &skill_lv, &casttime, &castcancel); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78460,10 +79043,10 @@ int HP_unit_skilluse_pos2(struct block_list *src, short skill_x, short skill_y, retVal___ = HPMHooks.source.unit.skilluse_pos2(src, skill_x, skill_y, skill_id, skill_lv, casttime, castcancel); } if( HPMHooks.count.HP_unit_skilluse_pos2_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel); + int (*postHookFunc) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos2_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_skilluse_pos2_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &skill_x, &skill_y, &skill_id, &skill_lv, &casttime, &castcancel); + retVal___ = postHookFunc(retVal___, src, skill_x, skill_y, skill_id, skill_lv, casttime, castcancel); } } return retVal___; @@ -78472,11 +79055,11 @@ int HP_unit_set_target(struct unit_data *ud, int target_id) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_set_target_pre ) { - int (*preHookFunc) (struct unit_data *ud, int *target_id); + int (*preHookFunc) (struct unit_data **ud, int *target_id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_target_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_set_target_pre[hIndex].func; - retVal___ = preHookFunc(ud, &target_id); + retVal___ = preHookFunc(&ud, &target_id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78487,10 +79070,10 @@ int HP_unit_set_target(struct unit_data *ud, int target_id) { retVal___ = HPMHooks.source.unit.set_target(ud, target_id); } if( HPMHooks.count.HP_unit_set_target_post ) { - int (*postHookFunc) (int retVal___, struct unit_data *ud, int *target_id); + int (*postHookFunc) (int retVal___, struct unit_data *ud, int target_id); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_target_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_set_target_post[hIndex].func; - retVal___ = postHookFunc(retVal___, ud, &target_id); + retVal___ = postHookFunc(retVal___, ud, target_id); } } return retVal___; @@ -78498,11 +79081,11 @@ int HP_unit_set_target(struct unit_data *ud, int target_id) { void HP_unit_stop_attack(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_unit_stop_attack_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_stop_attack_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78525,11 +79108,11 @@ int HP_unit_unattackable(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_unattackable_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_unattackable_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_unattackable_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78552,11 +79135,11 @@ int HP_unit_attack(struct block_list *src, int target_id, int continuous) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_attack_pre ) { - int (*preHookFunc) (struct block_list *src, int *target_id, int *continuous); + int (*preHookFunc) (struct block_list **src, int *target_id, int *continuous); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_attack_pre[hIndex].func; - retVal___ = preHookFunc(src, &target_id, &continuous); + retVal___ = preHookFunc(&src, &target_id, &continuous); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78567,10 +79150,10 @@ int HP_unit_attack(struct block_list *src, int target_id, int continuous) { retVal___ = HPMHooks.source.unit.attack(src, target_id, continuous); } if( HPMHooks.count.HP_unit_attack_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, int *continuous); + int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, int continuous); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_attack_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &target_id, &continuous); + retVal___ = postHookFunc(retVal___, src, target_id, continuous); } } return retVal___; @@ -78579,11 +79162,11 @@ int HP_unit_cancel_combo(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_cancel_combo_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_cancel_combo_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_cancel_combo_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78606,11 +79189,11 @@ bool HP_unit_can_reach_pos(struct block_list *bl, int x, int y, int easy) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_unit_can_reach_pos_pre ) { - bool (*preHookFunc) (struct block_list *bl, int *x, int *y, int *easy); + bool (*preHookFunc) (struct block_list **bl, int *x, int *y, int *easy); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_can_reach_pos_pre[hIndex].func; - retVal___ = preHookFunc(bl, &x, &y, &easy); + retVal___ = preHookFunc(&bl, &x, &y, &easy); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78621,10 +79204,10 @@ bool HP_unit_can_reach_pos(struct block_list *bl, int x, int y, int easy) { retVal___ = HPMHooks.source.unit.can_reach_pos(bl, x, y, easy); } if( HPMHooks.count.HP_unit_can_reach_pos_post ) { - bool (*postHookFunc) (bool retVal___, struct block_list *bl, int *x, int *y, int *easy); + bool (*postHookFunc) (bool retVal___, struct block_list *bl, int x, int y, int easy); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_can_reach_pos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &x, &y, &easy); + retVal___ = postHookFunc(retVal___, bl, x, y, easy); } } return retVal___; @@ -78633,11 +79216,11 @@ bool HP_unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int ran int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_unit_can_reach_bl_pre ) { - bool (*preHookFunc) (struct block_list *bl, struct block_list *tbl, int *range, int *easy, short *x, short *y); + bool (*preHookFunc) (struct block_list **bl, struct block_list **tbl, int *range, int *easy, short **x, short **y); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_bl_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_can_reach_bl_pre[hIndex].func; - retVal___ = preHookFunc(bl, tbl, &range, &easy, x, y); + retVal___ = preHookFunc(&bl, &tbl, &range, &easy, &x, &y); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78648,10 +79231,10 @@ bool HP_unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int ran retVal___ = HPMHooks.source.unit.can_reach_bl(bl, tbl, range, easy, x, y); } if( HPMHooks.count.HP_unit_can_reach_bl_post ) { - bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct block_list *tbl, int *range, int *easy, short *x, short *y); + bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_bl_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_can_reach_bl_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, tbl, &range, &easy, x, y); + retVal___ = postHookFunc(retVal___, bl, tbl, range, easy, x, y); } } return retVal___; @@ -78660,11 +79243,11 @@ int HP_unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_calc_pos_pre ) { - int (*preHookFunc) (struct block_list *bl, int *tx, int *ty, uint8 *dir); + int (*preHookFunc) (struct block_list **bl, int *tx, int *ty, uint8 *dir); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_calc_pos_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_calc_pos_pre[hIndex].func; - retVal___ = preHookFunc(bl, &tx, &ty, &dir); + retVal___ = preHookFunc(&bl, &tx, &ty, &dir); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78675,10 +79258,10 @@ int HP_unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir) { retVal___ = HPMHooks.source.unit.calc_pos(bl, tx, ty, dir); } if( HPMHooks.count.HP_unit_calc_pos_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *tx, int *ty, uint8 *dir); + int (*postHookFunc) (int retVal___, struct block_list *bl, int tx, int ty, uint8 dir); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_calc_pos_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_calc_pos_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &tx, &ty, &dir); + retVal___ = postHookFunc(retVal___, bl, tx, ty, dir); } } return retVal___; @@ -78687,11 +79270,11 @@ int HP_unit_attack_timer_sub(struct block_list *src, int tid, int64 tick) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_attack_timer_sub_pre ) { - int (*preHookFunc) (struct block_list *src, int *tid, int64 *tick); + int (*preHookFunc) (struct block_list **src, int *tid, int64 *tick); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_sub_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_attack_timer_sub_pre[hIndex].func; - retVal___ = preHookFunc(src, &tid, &tick); + retVal___ = preHookFunc(&src, &tid, &tick); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78702,10 +79285,10 @@ int HP_unit_attack_timer_sub(struct block_list *src, int tid, int64 tick) { retVal___ = HPMHooks.source.unit.attack_timer_sub(src, tid, tick); } if( HPMHooks.count.HP_unit_attack_timer_sub_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, int *tid, int64 *tick); + int (*postHookFunc) (int retVal___, struct block_list *src, int tid, int64 tick); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_sub_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_attack_timer_sub_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, &tid, &tick); + retVal___ = postHookFunc(retVal___, src, tid, tick); } } return retVal___; @@ -78714,11 +79297,11 @@ int HP_unit_skillcastcancel(struct block_list *bl, int type) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_skillcastcancel_pre ) { - int (*preHookFunc) (struct block_list *bl, int *type); + int (*preHookFunc) (struct block_list **bl, int *type); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_skillcastcancel_pre[hIndex].func; - retVal___ = preHookFunc(bl, &type); + retVal___ = preHookFunc(&bl, &type); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78729,10 +79312,10 @@ int HP_unit_skillcastcancel(struct block_list *bl, int type) { retVal___ = HPMHooks.source.unit.skillcastcancel(bl, type); } if( HPMHooks.count.HP_unit_skillcastcancel_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, int *type); + int (*postHookFunc) (int retVal___, struct block_list *bl, int type); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_skillcastcancel_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &type); + retVal___ = postHookFunc(retVal___, bl, type); } } return retVal___; @@ -78740,11 +79323,11 @@ int HP_unit_skillcastcancel(struct block_list *bl, int type) { void HP_unit_dataset(struct block_list *bl) { int hIndex = 0; if( HPMHooks.count.HP_unit_dataset_pre ) { - void (*preHookFunc) (struct block_list *bl); + void (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_dataset_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_dataset_pre[hIndex].func; - preHookFunc(bl); + preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78767,11 +79350,11 @@ int HP_unit_counttargeted(struct block_list *bl) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_counttargeted_pre ) { - int (*preHookFunc) (struct block_list *bl); + int (*preHookFunc) (struct block_list **bl); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_counttargeted_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_counttargeted_pre[hIndex].func; - retVal___ = preHookFunc(bl); + retVal___ = preHookFunc(&bl); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78794,11 +79377,11 @@ int HP_unit_fixdamage(struct block_list *src, struct block_list *target, int sde int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_fixdamage_pre ) { - int (*preHookFunc) (struct block_list *src, struct block_list *target, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); + int (*preHookFunc) (struct block_list **src, struct block_list **target, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_fixdamage_pre[hIndex].func; - retVal___ = preHookFunc(src, target, &sdelay, &ddelay, &damage, &div, &type, &damage2); + retVal___ = preHookFunc(&src, &target, &sdelay, &ddelay, &damage, &div, &type, &damage2); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78809,10 +79392,10 @@ int HP_unit_fixdamage(struct block_list *src, struct block_list *target, int sde retVal___ = HPMHooks.source.unit.fixdamage(src, target, sdelay, ddelay, damage, div, type, damage2); } if( HPMHooks.count.HP_unit_fixdamage_post ) { - int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2); + int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_fixdamage_post[hIndex].func; - retVal___ = postHookFunc(retVal___, src, target, &sdelay, &ddelay, &damage, &div, &type, &damage2); + retVal___ = postHookFunc(retVal___, src, target, sdelay, ddelay, damage, div, type, damage2); } } return retVal___; @@ -78821,11 +79404,11 @@ int HP_unit_changeviewsize(struct block_list *bl, short size) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_changeviewsize_pre ) { - int (*preHookFunc) (struct block_list *bl, short *size); + int (*preHookFunc) (struct block_list **bl, short *size); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_changeviewsize_pre[hIndex].func; - retVal___ = preHookFunc(bl, &size); + retVal___ = preHookFunc(&bl, &size); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78836,10 +79419,10 @@ int HP_unit_changeviewsize(struct block_list *bl, short size) { retVal___ = HPMHooks.source.unit.changeviewsize(bl, size); } if( HPMHooks.count.HP_unit_changeviewsize_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, short *size); + int (*postHookFunc) (int retVal___, struct block_list *bl, short size); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_changeviewsize_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &size); + retVal___ = postHookFunc(retVal___, bl, size); } } return retVal___; @@ -78848,11 +79431,11 @@ int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_remove_map_pre ) { - int (*preHookFunc) (struct block_list *bl, clr_type *clrtype, const char *file, int *line, const char *func); + int (*preHookFunc) (struct block_list **bl, clr_type *clrtype, const char **file, int *line, const char **func); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_remove_map_pre[hIndex].func; - retVal___ = preHookFunc(bl, &clrtype, file, &line, func); + retVal___ = preHookFunc(&bl, &clrtype, &file, &line, &func); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78863,10 +79446,10 @@ int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file retVal___ = HPMHooks.source.unit.remove_map(bl, clrtype, file, line, func); } if( HPMHooks.count.HP_unit_remove_map_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type *clrtype, const char *file, int *line, const char *func); + int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type clrtype, const char *file, int line, const char *func); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_remove_map_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &clrtype, file, &line, func); + retVal___ = postHookFunc(retVal___, bl, clrtype, file, line, func); } } return retVal___; @@ -78874,11 +79457,11 @@ int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file void HP_unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype) { int hIndex = 0; if( HPMHooks.count.HP_unit_remove_map_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd, clr_type *clrtype); + void (*preHookFunc) (struct map_session_data **sd, clr_type *clrtype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_remove_map_pc_pre[hIndex].func; - preHookFunc(sd, &clrtype); + preHookFunc(&sd, &clrtype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78889,10 +79472,10 @@ void HP_unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype) { HPMHooks.source.unit.remove_map_pc(sd, clrtype); } if( HPMHooks.count.HP_unit_remove_map_pc_post ) { - void (*postHookFunc) (struct map_session_data *sd, clr_type *clrtype); + void (*postHookFunc) (struct map_session_data *sd, clr_type clrtype); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pc_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_remove_map_pc_post[hIndex].func; - postHookFunc(sd, &clrtype); + postHookFunc(sd, clrtype); } } return; @@ -78900,11 +79483,11 @@ void HP_unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype) { void HP_unit_free_pc(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_unit_free_pc_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pc_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_free_pc_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78927,11 +79510,11 @@ int HP_unit_free(struct block_list *bl, clr_type clrtype) { int hIndex = 0; int retVal___ = 0; if( HPMHooks.count.HP_unit_free_pre ) { - int (*preHookFunc) (struct block_list *bl, clr_type *clrtype); + int (*preHookFunc) (struct block_list **bl, clr_type *clrtype); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_unit_free_pre[hIndex].func; - retVal___ = preHookFunc(bl, &clrtype); + retVal___ = preHookFunc(&bl, &clrtype); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -78942,10 +79525,10 @@ int HP_unit_free(struct block_list *bl, clr_type clrtype) { retVal___ = HPMHooks.source.unit.free(bl, clrtype); } if( HPMHooks.count.HP_unit_free_post ) { - int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type *clrtype); + int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type clrtype); for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_unit_free_post[hIndex].func; - retVal___ = postHookFunc(retVal___, bl, &clrtype); + retVal___ = postHookFunc(retVal___, bl, clrtype); } } return retVal___; @@ -78969,10 +79552,10 @@ void HP_vending_init(bool minimal) { HPMHooks.source.vending.init(minimal); } if( HPMHooks.count.HP_vending_init_post ) { - void (*postHookFunc) (bool *minimal); + 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(&minimal); + postHookFunc(minimal); } } return; @@ -79006,11 +79589,11 @@ void HP_vending_final(void) { void HP_vending_close(struct map_session_data *sd) { int hIndex = 0; if( HPMHooks.count.HP_vending_close_pre ) { - void (*preHookFunc) (struct map_session_data *sd); + void (*preHookFunc) (struct map_session_data **sd); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_close_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_close_pre[hIndex].func; - preHookFunc(sd); + preHookFunc(&sd); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -79032,11 +79615,11 @@ void HP_vending_close(struct map_session_data *sd) { void HP_vending_open(struct map_session_data *sd, const char *message, const uint8 *data, int count) { int hIndex = 0; if( HPMHooks.count.HP_vending_open_pre ) { - void (*preHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int *count); + void (*preHookFunc) (struct map_session_data **sd, const char **message, const uint8 **data, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_open_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_open_pre[hIndex].func; - preHookFunc(sd, message, data, &count); + preHookFunc(&sd, &message, &data, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -79047,10 +79630,10 @@ void HP_vending_open(struct map_session_data *sd, const char *message, const uin HPMHooks.source.vending.open(sd, message, data, count); } if( HPMHooks.count.HP_vending_open_post ) { - void (*postHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int *count); + void (*postHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_open_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_vending_open_post[hIndex].func; - postHookFunc(sd, message, data, &count); + postHookFunc(sd, message, data, count); } } return; @@ -79058,11 +79641,11 @@ void HP_vending_open(struct map_session_data *sd, const char *message, const uin void HP_vending_list(struct map_session_data *sd, unsigned int id) { int hIndex = 0; if( HPMHooks.count.HP_vending_list_pre ) { - void (*preHookFunc) (struct map_session_data *sd, unsigned int *id); + void (*preHookFunc) (struct map_session_data **sd, unsigned int *id); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_list_pre[hIndex].func; - preHookFunc(sd, &id); + preHookFunc(&sd, &id); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -79073,10 +79656,10 @@ void HP_vending_list(struct map_session_data *sd, unsigned int id) { HPMHooks.source.vending.list(sd, id); } if( HPMHooks.count.HP_vending_list_post ) { - void (*postHookFunc) (struct map_session_data *sd, unsigned int *id); + void (*postHookFunc) (struct map_session_data *sd, unsigned int id); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_vending_list_post[hIndex].func; - postHookFunc(sd, &id); + postHookFunc(sd, id); } } return; @@ -79084,11 +79667,11 @@ void HP_vending_list(struct map_session_data *sd, unsigned int id) { void HP_vending_purchase(struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count) { int hIndex = 0; if( HPMHooks.count.HP_vending_purchase_pre ) { - void (*preHookFunc) (struct map_session_data *sd, int *aid, unsigned int *uid, const uint8 *data, int *count); + void (*preHookFunc) (struct map_session_data **sd, int *aid, unsigned int *uid, const uint8 **data, int *count); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_purchase_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_purchase_pre[hIndex].func; - preHookFunc(sd, &aid, &uid, data, &count); + preHookFunc(&sd, &aid, &uid, &data, &count); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -79099,10 +79682,10 @@ void HP_vending_purchase(struct map_session_data *sd, int aid, unsigned int uid, HPMHooks.source.vending.purchase(sd, aid, uid, data, count); } if( HPMHooks.count.HP_vending_purchase_post ) { - void (*postHookFunc) (struct map_session_data *sd, int *aid, unsigned int *uid, const uint8 *data, int *count); + void (*postHookFunc) (struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_purchase_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_vending_purchase_post[hIndex].func; - postHookFunc(sd, &aid, &uid, data, &count); + postHookFunc(sd, aid, uid, data, count); } } return; @@ -79111,11 +79694,11 @@ bool HP_vending_search(struct map_session_data *sd, unsigned short nameid) { int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_vending_search_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid); + bool (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_search_pre[hIndex].func; - retVal___ = preHookFunc(sd, &nameid); + retVal___ = preHookFunc(&sd, &nameid); } if( *HPMforce_return ) { *HPMforce_return = false; @@ -79126,10 +79709,10 @@ bool HP_vending_search(struct map_session_data *sd, unsigned short nameid) { retVal___ = HPMHooks.source.vending.search(sd, nameid); } if( HPMHooks.count.HP_vending_search_post ) { - bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short *nameid); + bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short nameid); for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_post; hIndex++ ) { postHookFunc = HPMHooks.list.HP_vending_search_post[hIndex].func; - retVal___ = postHookFunc(retVal___, sd, &nameid); + retVal___ = postHookFunc(retVal___, sd, nameid); } } return retVal___; @@ -79138,11 +79721,11 @@ bool HP_vending_searchall(struct map_session_data *sd, const struct s_search_sto int hIndex = 0; bool retVal___ = false; if( HPMHooks.count.HP_vending_searchall_pre ) { - bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s); + bool (*preHookFunc) (struct map_session_data **sd, const struct s_search_store_search **s); *HPMforce_return = false; for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_searchall_pre; hIndex++ ) { preHookFunc = HPMHooks.list.HP_vending_searchall_pre[hIndex].func; - retVal___ = preHookFunc(sd, s); + retVal___ = preHookFunc(&sd, &s); } if( *HPMforce_return ) { *HPMforce_return = false; diff --git a/src/plugins/HPMHooking/HPMHooking_map.sources.inc b/src/plugins/HPMHooking/HPMHooking_map.sources.inc index 1af35ab21..f98330b88 100644 --- a/src/plugins/HPMHooking/HPMHooking_map.sources.inc +++ b/src/plugins/HPMHooking/HPMHooking_map.sources.inc @@ -23,6 +23,8 @@ * as it will get overwritten. */ +/* GENERATED FILE DO NOT EDIT */ + memcpy(&HPMHooks.source.HCache, HCache, sizeof(struct HCache_interface)); memcpy(&HPMHooks.source.atcommand, atcommand, sizeof(struct atcommand_interface)); memcpy(&HPMHooks.source.battle, battle, sizeof(struct battle_interface)); diff --git a/src/plugins/Makefile.in b/src/plugins/Makefile.in index c3baa2f30..42d6d821c 100644 --- a/src/plugins/Makefile.in +++ b/src/plugins/Makefile.in @@ -47,7 +47,7 @@ PLUGINS = sample db2sql HPMHooking_char HPMHooking_login HPMHooking_map $(MYPLUG COMMON_D = ../common # Includes private headers (plugins might need them) -COMMON_H = $(wildcard $(COMMON_D)/*.h) +COMMON_H = $(wildcard $(COMMON_D)/*.h) ../plugins/HPMHooking.h COMMON_INCLUDE = -I.. THIRDPARTY_INCLUDE = -I../../3rdparty diff --git a/src/plugins/constdb2doc.c b/src/plugins/constdb2doc.c index cb0b82278..d211c46e2 100644 --- a/src/plugins/constdb2doc.c +++ b/src/plugins/constdb2doc.c @@ -177,7 +177,8 @@ void do_constdb2doc(void) constdb2doc_itemdb(); - fprintf(out_fp, "> End of list\n"); + fprintf(out_fp, "> End of list\n\n"); + fprintf(out_fp, "<!--GENERATED FILE DO NOT EDIT-->\n"); fclose(out_fp); } diff --git a/src/plugins/db2sql.c b/src/plugins/db2sql.c index 510a56e2c..af5ab99af 100644 --- a/src/plugins/db2sql.c +++ b/src/plugins/db2sql.c @@ -78,6 +78,7 @@ int (*mob_read_db_sub) (struct config_setting_t *it, int n, const char *source); */ void hstr(const char *str) { + nullpo_retv(str); if (strlen(str) > tosql.buf[3].len) { tosql.buf[3].len = tosql.buf[3].len + strlen(str) + 1000; RECREATE(tosql.buf[3].p,char,tosql.buf[3].len); @@ -117,7 +118,9 @@ void db2sql_fileheader(void) "-- NOTE: This file was auto-generated and should never be manually edited,\n" "-- as it will get overwritten. If you need to modify this file,\n" "-- please consider modifying the corresponding .conf file inside\n" - "-- the db folder, and then re-run the db2sql plugin.\n" + "-- the db folder, and then re-run the db2sql plugin.\n\n" + + "-- GENERATED FILE DO NOT EDIT --\n" "\n", year); } @@ -288,7 +291,7 @@ int itemdb2sql_sub(struct config_setting_t *entry, int n, const char *source) } else { ui64 = UINT64_MAX; } - StrBuf->Printf(&buf, "'0x%"PRIX64"',", ui64); + StrBuf->Printf(&buf, "'%"PRIu64"',", ui64); // equip_upper if (libconfig->setting_lookup_int(entry, "Upper", &i32) && i32 >= 0) @@ -376,8 +379,7 @@ int itemdb2sql_sub(struct config_setting_t *entry, int n, const char *source) } // script - if (it->script) { - libconfig->setting_lookup_string(entry, "Script", &bonus); + if (it->script && libconfig->setting_lookup_string(entry, "Script", &bonus)) { hstr(bonus); str = tosql.buf[3].p; if (strlen(str) > tosql.buf[0].len) { @@ -385,12 +387,13 @@ int itemdb2sql_sub(struct config_setting_t *entry, int n, const char *source) RECREATE(tosql.buf[0].p,char,tosql.buf[0].len); } SQL->EscapeString(NULL, tosql.buf[0].p, str); + StrBuf->Printf(&buf, "'%s',", tosql.buf[0].p); + } else { + StrBuf->AppendStr(&buf, "'',"); } - StrBuf->Printf(&buf, "'%s',", it->script?tosql.buf[0].p:""); // equip_script - if (it->equip_script) { - libconfig->setting_lookup_string(entry, "OnEquipScript", &bonus); + if (it->equip_script && libconfig->setting_lookup_string(entry, "OnEquipScript", &bonus)) { hstr(bonus); str = tosql.buf[3].p; if (strlen(str) > tosql.buf[1].len) { @@ -398,12 +401,13 @@ int itemdb2sql_sub(struct config_setting_t *entry, int n, const char *source) RECREATE(tosql.buf[1].p,char,tosql.buf[1].len); } SQL->EscapeString(NULL, tosql.buf[1].p, str); + StrBuf->Printf(&buf, "'%s',", tosql.buf[1].p); + } else { + StrBuf->AppendStr(&buf, "'',"); } - StrBuf->Printf(&buf, "'%s',", it->equip_script?tosql.buf[1].p:""); // unequip_script - if (it->unequip_script) { - libconfig->setting_lookup_string(entry, "OnUnequipScript", &bonus); + if (it->unequip_script && libconfig->setting_lookup_string(entry, "OnUnequipScript", &bonus)) { hstr(bonus); str = tosql.buf[3].p; if (strlen(str) > tosql.buf[2].len) { @@ -411,8 +415,10 @@ int itemdb2sql_sub(struct config_setting_t *entry, int n, const char *source) RECREATE(tosql.buf[2].p,char,tosql.buf[2].len); } SQL->EscapeString(NULL, tosql.buf[2].p, str); + StrBuf->Printf(&buf, "'%s'", tosql.buf[2].p); + } else { + StrBuf->AppendStr(&buf, "''"); } - StrBuf->Printf(&buf, "'%s'", it->unequip_script?tosql.buf[2].p:""); fprintf(tosql.fp, "REPLACE INTO `%s` VALUES (%s);\n", tosql.db_name, StrBuf->Value(&buf)); @@ -619,7 +625,7 @@ int mobdb2sql_sub(struct config_setting_t *mobt, int n, const char *source) StrBuf->Printf(&buf, "%d,", md->status.def_ele + 20 * md->status.ele_lv); // Mode - StrBuf->Printf(&buf, "0x%X,", md->status.mode); + StrBuf->Printf(&buf, "%u,", md->status.mode); // Speed StrBuf->Printf(&buf, "%u,", md->status.speed); diff --git a/src/plugins/dbghelpplug.c b/src/plugins/dbghelpplug.c index 6c02b1a12..cf8be0901 100644 --- a/src/plugins/dbghelpplug.c +++ b/src/plugins/dbghelpplug.c @@ -446,17 +446,17 @@ Dhp__PrintProcessInfo( fprintf(log_file, "eip=%08x esp=%08x ebp=%08x iopl=%1x %s %s %s %s %s %s %s %s %s %s\n", context->Eip, context->Esp, context->Ebp, - (context->EFlags >> 12) & 3, // IOPL level value - context->EFlags & 0x00100000 ? "vip" : " ", // VIP (virtual interrupt pending) - context->EFlags & 0x00080000 ? "vif" : " ", // VIF (virtual interrupt flag) - context->EFlags & 0x00000800 ? "ov" : "nv", // VIF (virtual interrupt flag) - context->EFlags & 0x00000400 ? "dn" : "up", // OF (overflow flag) - context->EFlags & 0x00000200 ? "ei" : "di", // IF (interrupt enable flag) - context->EFlags & 0x00000080 ? "ng" : "pl", // SF (sign flag) - context->EFlags & 0x00000040 ? "zr" : "nz", // ZF (zero flag) - context->EFlags & 0x00000010 ? "ac" : "na", // AF (aux carry flag) - context->EFlags & 0x00000004 ? "po" : "pe", // PF (parity flag) - context->EFlags & 0x00000001 ? "cy" : "nc"); // CF (carry flag) + (context->EFlags >> 12) & 3, // IOPL level value + (context->EFlags & 0x00100000) ? "vip" : " ", // VIP (virtual interrupt pending) + (context->EFlags & 0x00080000) ? "vif" : " ", // VIF (virtual interrupt flag) + (context->EFlags & 0x00000800) ? "ov" : "nv", // VIF (virtual interrupt flag) + (context->EFlags & 0x00000400) ? "dn" : "up", // OF (overflow flag) + (context->EFlags & 0x00000200) ? "ei" : "di", // IF (interrupt enable flag) + (context->EFlags & 0x00000080) ? "ng" : "pl", // SF (sign flag) + (context->EFlags & 0x00000040) ? "zr" : "nz", // ZF (zero flag) + (context->EFlags & 0x00000010) ? "ac" : "na", // AF (aux carry flag) + (context->EFlags & 0x00000004) ? "po" : "pe", // PF (parity flag) + (context->EFlags & 0x00000001) ? "cy" : "nc"); // CF (carry flag) } if( context->ContextFlags & CONTEXT_SEGMENTS ) { @@ -467,8 +467,7 @@ Dhp__PrintProcessInfo( context->SegDs, context->SegEs, context->SegFs, - context->SegGs, - context->EFlags); + context->SegGs); if( context->ContextFlags & CONTEXT_CONTROL ) fprintf(log_file, " efl=%08x", @@ -951,7 +950,6 @@ Dhp__PrintDataValue( // ULONG64 length = 0; DWORD basetype; - BOOL isValid = TRUE; assert( pInterData != NULL ); log_file = pInterData->log_file; @@ -1260,7 +1258,7 @@ Dhp__PrintDataInfo( } else if( pSymInfo->Flags & SYMFLAG_REGISTER ) { - scope = ( pSymInfo->Flags & SYMFLAG_PARAMETER ? PARAM : LOCAL ); // register, optimized out(?) + scope = (pSymInfo->Flags & SYMFLAG_PARAMETER) ? PARAM : LOCAL; // register, optimized out(?) } else { diff --git a/src/plugins/generate-translations.c b/src/plugins/generate-translations.c new file mode 100644 index 000000000..50a0f162c --- /dev/null +++ b/src/plugins/generate-translations.c @@ -0,0 +1,256 @@ +/** + * This file is part of Hercules. + * http://herc.ws - http://github.com/HerculesWS/Hercules + * + * Copyright (C) 2016 Hercules Dev Team + * + * Hercules is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ +#include "config/core.h" + +#include "common/hercules.h" +#include "common/cbasetypes.h" +#include "common/memmgr.h" +#include "common/showmsg.h" +#include "common/strlib.h" +#include "map/atcommand.h" +#include "map/map.h" +#include "map/script.h" + +#include "plugins/HPMHooking.h" +#include "common/HPMDataCheck.h" + +#include <stdio.h> +#include <stdlib.h> + +HPExport struct hplugin_info pinfo = { + "generate-translations", // Plugin name + SERVER_TYPE_MAP, // Which server types this plugin works with? + "0.1", // Plugin version + HPM_VERSION, // HPM Version (don't change, macro is automatically updated) +}; + +struct DBMap *translatable_strings; // string map parsed (used when exporting strings only) +/* Set during startup when attempting to export the lang, unset after server initialization is over */ +FILE *lang_export_fp; +char *lang_export_file;/* for lang_export_fp */ +struct script_string_buf lang_export_line_buf; +struct script_string_buf lang_export_escaped_buf; + +/// Whether the translations template generator will automatically run. +bool generating_translations = false; + +/** + * --generate-translations + * + * Creates "./generated_translations.pot" + * @see cmdline->exec + */ +CMDLINEARG(generatetranslations) +{ + lang_export_file = aStrdup("./generated_translations.pot"); + + if ((lang_export_fp = fopen(lang_export_file, "wb")) == NULL) { + ShowError("export-dialog: failed to open '%s' for writing\n", lang_export_file); + } else { + time_t t = time(NULL); + struct tm *lt = localtime(&t); + int year = lt->tm_year+1900; + fprintf(lang_export_fp, + "# This file is part of Hercules.\n" + "# http://herc.ws - http://github.com/HerculesWS/Hercules\n" + "#\n" + "# Copyright (C) 2013-%d Hercules Dev Team\n" + "#\n" + "# Hercules is free software: you can redistribute it and/or modify\n" + "# it under the terms of the GNU General Public License as published by\n" + "# the Free Software Foundation, either version 3 of the License, or\n" + "# (at your option) any later version.\n" + "#\n" + "# This program is distributed in the hope that it will be useful,\n" + "# but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + "# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "# GNU General Public License for more details.\n" + "#\n" + "# You should have received a copy of the GNU General Public License\n" + "# along with this program. If not, see <http://www.gnu.org/licenses/>.\n", + year); + } + generating_translations = true; + return true; +} + +void script_add_translatable_string_posthook(const struct script_string_buf *string, const char *start_point) +{ + bool duplicate = true; + bool is_translatable_string = false; + bool is_translatable_fmtstring = false; + + if (!generating_translations || lang_export_fp == NULL) + return; + + /* When exporting we don't know what is a translation and what isn't */ + if (VECTOR_LENGTH(*string) > 1) { + // The length of *string will always be at least 1 because of the '\0' + if (translatable_strings == NULL) { + translatable_strings = strdb_alloc(DB_OPT_DUP_KEY|DB_OPT_ALLOW_NULL_DATA, 0); + } + + if (!strdb_exists(translatable_strings, VECTOR_DATA(*string))) { + strdb_put(translatable_strings, VECTOR_DATA(*string), NULL); + duplicate = false; + } + } + + if (!duplicate) { + if (script->syntax.last_func == script->buildin_mes_offset + || script->syntax.last_func == script->buildin_select_offset + || script->syntax.lang_macro_active + ) { + is_translatable_string = true; + } else if (script->syntax.last_func == script->buildin_mesf_offset + || script->syntax.lang_macro_fmtstring_active + ) { + is_translatable_fmtstring = true; + } + } + + if (is_translatable_string || is_translatable_fmtstring) { + const char *line_start = start_point; + const char *line_end = start_point; + int line_length; + bool has_percent_sign = false; + + if (!is_translatable_fmtstring && strchr(VECTOR_DATA(*string), '%') != NULL) { + has_percent_sign = true; + } + + while (line_start > script->parser_current_src && *line_start != '\n') + line_start--; + + while (*line_end != '\n' && *line_end != '\0') + line_end++; + + line_length = (int)(line_end - line_start); + if (line_length > 0) { + VECTOR_ENSURE(lang_export_line_buf, line_length + 1, 512); + VECTOR_PUSHARRAY(lang_export_line_buf, line_start, line_length); + VECTOR_PUSH(lang_export_line_buf, '\0'); + + normalize_name(VECTOR_DATA(lang_export_line_buf), "\r\n\t "); // [!] Note: VECTOR_LENGTH() will lie. + } + + VECTOR_ENSURE(lang_export_escaped_buf, 4*VECTOR_LENGTH(*string)+1, 1); + VECTOR_LENGTH(lang_export_escaped_buf) = (int)sv->escape_c(VECTOR_DATA(lang_export_escaped_buf), + VECTOR_DATA(*string), + VECTOR_LENGTH(*string)-1, /* exclude null terminator */ + "\""); + VECTOR_PUSH(lang_export_escaped_buf, '\0'); + + fprintf(lang_export_fp, "\n#: %s\n" + "# %s\n" + "%s" + "msgctxt \"%s\"\n" + "msgid \"%s\"\n" + "msgstr \"\"\n", + script->parser_current_file ? script->parser_current_file : "Unknown File", + VECTOR_DATA(lang_export_line_buf), + is_translatable_fmtstring ? "#, c-format\n" : (has_percent_sign ? "#, no-c-format\n" : ""), + script->parser_current_npc_name ? script->parser_current_npc_name : "Unknown NPC", + VECTOR_DATA(lang_export_escaped_buf) + ); + VECTOR_TRUNCATE(lang_export_line_buf); + VECTOR_TRUNCATE(lang_export_escaped_buf); + } +} + +struct script_code *parse_script_prehook(const char **src, const char **file, int *line, int *options, int **retval) +{ + if (translatable_strings != NULL) { + db_destroy(translatable_strings); + translatable_strings = NULL; + } + return NULL; +} + +void script_parser_clean_leftovers_posthook(void) +{ + if (translatable_strings != NULL) { + db_destroy(translatable_strings); + translatable_strings = NULL; + } + + VECTOR_CLEAR(lang_export_line_buf); + VECTOR_CLEAR(lang_export_escaped_buf); +} + +bool msg_config_read_posthook(bool retVal, const char *cfg_name, bool allow_override) +{ + static int called = 1; + + if (!generating_translations || lang_export_fp == NULL) + return retVal; + + if (!retVal) + return retVal; + + if (++called == 1) { // Original + int i; + for (i = 0; i < MAX_MSG; i++) { + if (atcommand->msg_table[0][i] == NULL) + continue; + fprintf(lang_export_fp, "msgctxt \"messages.conf\"\n" + "msgid \"%s\"\n" + "msgstr \"\"\n", + atcommand->msg_table[0][i] + ); + } + } + + return retVal; +} + +HPExport void server_preinit(void) +{ + addArg("--generate-translations", false, generatetranslations, + "Creates './generated_translations.pot' file with all translateable strings from scripts, server terminates afterwards."); + VECTOR_INIT(lang_export_line_buf); + VECTOR_INIT(lang_export_escaped_buf); + addHookPost(script, add_translatable_string, script_add_translatable_string_posthook); + addHookPre(script, parse, parse_script_prehook); + addHookPost(script, parser_clean_leftovers, script_parser_clean_leftovers_posthook); + addHookPost(atcommand, msg_read, msg_config_read_posthook); +} + +HPExport void plugin_init(void) +{ +} + +HPExport void server_online(void) +{ + if (generating_translations && lang_export_fp != NULL) { + ShowInfo("Lang exported to '%s'\n", lang_export_file); + fclose(lang_export_fp); + lang_export_fp = NULL; + } + core->runflag = CORE_ST_STOP; +} + +HPExport void plugin_final(void) +{ + if (lang_export_file != NULL) { + aFree(lang_export_file); + lang_export_file = NULL; + } +} diff --git a/src/plugins/sample.c b/src/plugins/sample.c index 8fba2f4df..b1ff4b39f 100644 --- a/src/plugins/sample.c +++ b/src/plugins/sample.c @@ -29,6 +29,7 @@ #include "map/pc.h" #include "map/script.h" +#include "plugins/HPMHooking.h" #include "common/HPMDataCheck.h" /* should always be the last Hercules file included! (if you don't make it last, it'll intentionally break compile time) */ #include <stdio.h> @@ -113,20 +114,23 @@ void sample_packet0f3(int fd) { } int my_pc_dropitem_storage;/* storage var */ /* my custom prehook for pc_dropitem, checks if amount of item being dropped is higher than 1 and if so cap it to 1 and store the value of how much it was */ -int my_pc_dropitem_pre(struct map_session_data *sd,int *n,int *amount) { +int my_pc_dropitem_pre(struct map_session_data **sd, int *n, int *amount) +{ my_pc_dropitem_storage = 0; - if( *amount > 1 ) { + if (*amount > 1) { my_pc_dropitem_storage = *amount; *amount = 1; } return 0; } /* postHook receive retVal as the first param, allows posthook to act accordingly to whatever the original was going to return */ -int my_pc_dropitem_post(int retVal, struct map_session_data *sd,int *n,int *amount) { - if( retVal != 1 ) return retVal;/* we don't do anything if pc_dropitem didn't return 1 (success) */ - if( my_pc_dropitem_storage ) {/* signs whether pre-hook did this */ +int my_pc_dropitem_post(int retVal, struct map_session_data *sd, int n, int amount) +{ + if (retVal != 1) + return retVal;/* we don't do anything if pc_dropitem didn't return 1 (success) */ + if (my_pc_dropitem_storage) {/* signs whether pre-hook did this */ char output[99]; - safesnprintf(output,99,"[ Warning ] you can only drop 1 item at a time, capped from %d to 1",my_pc_dropitem_storage); + safesnprintf(output, 99, "[ Warning ] you can only drop 1 item at a time, capped from %d to 1", my_pc_dropitem_storage); clif->messagecolor_self(sd->fd, COLOR_RED, output); } return 1; @@ -199,13 +203,13 @@ HPExport void plugin_init (void) { /* in this sample we add a PreHook to pc->dropitem */ /* to identify whether the item being dropped is on amount higher than 1 */ /* if so, it stores the amount on a variable (my_pc_dropitem_storage) and changes the amount to 1 */ - addHookPre("pc->dropitem",my_pc_dropitem_pre); + addHookPre(pc, dropitem, my_pc_dropitem_pre); /* in this sample we add a PostHook to pc->dropitem */ /* if the original pc->dropitem was successful and the amount stored on my_pc_dropitem_storage is higher than 1, */ /* our posthook will display a message to the user about the cap */ /* - by checking whether it was successful (retVal value) it allows for the originals conditions to take place */ - addHookPost("pc->dropitem",my_pc_dropitem_post); + addHookPost(pc, dropitem, my_pc_dropitem_post); } } /* triggered when server starts loading, before any server-specific data is set */ diff --git a/src/test/test_libconfig.c b/src/test/test_libconfig.c index a3b233b98..e0a470e21 100644 --- a/src/test/test_libconfig.c +++ b/src/test/test_libconfig.c @@ -113,6 +113,7 @@ static const char *test_libconfig_read(void) libconfig->destroy(&config); return "Unable to read from file '" FILENAME "'."; } + fclose(fp); #undef FILENAME if (config.root == NULL) { libconfig->destroy(&config); @@ -200,7 +201,6 @@ static const char *test_libconfig_set_include_dir(void) static const char *test_libconfig_lookup(void) { struct config_t config; - struct config_setting_t *t = NULL; int32 i32; int64 i64; double f; @@ -221,12 +221,12 @@ static const char *test_libconfig_lookup(void) return "Unable to parse configuration."; } - if ((t = libconfig->lookup(&config, "Setting_Int")) == NULL) { + if (libconfig->lookup(&config, "Setting_Int") == NULL) { libconfig->destroy(&config); return "libconfig->lookup failed."; } - if ((t = libconfig->setting_lookup(config.root, "Setting_Int")) == NULL) { + if (libconfig->setting_lookup(config.root, "Setting_Int") == NULL) { libconfig->destroy(&config); return "libconfig->setting_lookup failed."; } diff --git a/src/test/test_spinlock.c b/src/test/test_spinlock.c index 38186a975..6ffc4eafc 100644 --- a/src/test/test_spinlock.c +++ b/src/test/test_spinlock.c @@ -91,9 +91,9 @@ int do_init(int argc, char **argv){ // Everything fine? if (val != (THRC*PERINC)) { - printf("FAILED! (Result: %u, Expected: %u)\n", val, (THRC*PERINC)); + printf("FAILED! (Result: %u, Expected: %d)\n", val, (THRC*PERINC)); } else { - printf("OK! (Result: %u, Expected: %u)\n", val, (THRC*PERINC)); + printf("OK! (Result: %u, Expected: %d)\n", val, (THRC*PERINC)); ok++; } diff --git a/src/tool/mapcache.c b/src/tool/mapcache.c index ec735e4e6..41dfcf022 100644 --- a/src/tool/mapcache.c +++ b/src/tool/mapcache.c @@ -67,11 +67,6 @@ struct map_info { int32 len; }; - /************************************* - * Big-endian compatibility functions * - * Moved to utils.h * - *************************************/ - // Reads a map from GRF's GAT and RSW files int read_map(char *name, struct map_data *m) { |