-Harmonize skillid, skill_num, skillnum, skill, to skill_id and same for skill_lv

-Optimise type from int to int16 in order to reduce ram consumtion.

git-svn-id: https://svn.code.sf.net/p/rathena/svn/trunk@17065 54d463be-8e91-2dee-dedb-b68131a5f0ec

src/char/int_guild.c

@@ -1031,12 +1031,12 @@ int mapif_guild_memberinfochanged(int guild_id,int account_id,int char_id, int t
 }
 
 // ACK guild skill up
-int mapif_guild_skillupack(int guild_id,int skill_num,int account_id)
+int mapif_guild_skillupack(int guild_id,uint16 skill_id,int account_id)
 {
 	unsigned char buf[14];
 	WBUFW(buf, 0)=0x383c;
 	WBUFL(buf, 2)=guild_id;
-	WBUFL(buf, 6)=skill_num;
+	WBUFL(buf, 6)=skill_id;
 	WBUFL(buf,10)=account_id;
 	mapif_sendall(buf,14);
 	return 0;
@@ -1620,10 +1620,10 @@ int mapif_parse_GuildPosition(int fd,int guild_id,int idx,struct guild_position
 }
 
 // Guild Skill UP
-int mapif_parse_GuildSkillUp(int fd,int guild_id,int skill_num,int account_id,int max)
+int mapif_parse_GuildSkillUp(int fd,int guild_id,uint16 skill_id,int account_id,int max)
 {
 	struct guild * g;
-	int idx = skill_num - GD_SKILLBASE;
+	int idx = skill_id - GD_SKILLBASE;
 
 	g = inter_guild_fromsql(guild_id);
 	if(g == NULL || idx < 0 || idx >= MAX_GUILDSKILL)
@@ -1635,7 +1635,7 @@ int mapif_parse_GuildSkillUp(int fd,int guild_id,int skill_num,int account_id,in
 		g->skill_point--;
 		if (!guild_calcinfo(g))
 			mapif_guild_info(-1,g);
-		mapif_guild_skillupack(guild_id,skill_num,account_id);
+		mapif_guild_skillupack(guild_id,skill_id,account_id);
 		g->save_flag |= (GS_LEVEL|GS_SKILL); // Change guild & guild_skill
 	}
 	return 0;

src/common/mmo.h

@@ -545,7 +545,7 @@ enum { //Change Guild Infos
 	GBI_EXP	=1,		// Guild Experience (EXP)
 	GBI_GUILDLV,		// Guild level
 	GBI_SKILLPOINT,		// Guild skillpoints
-	GBI_SKILLLV,		// Guild skilllv ?? seem unused
+	GBI_skill_lv,		// Guild skill_lv ?? seem unused
 };
 
 enum { //Change Member Infos

src/map/atcommand.c

@@ -445,7 +445,7 @@ ACMD_FUNC(mapmove)
 	char map_name[MAP_NAME_LENGTH_EXT];
 	unsigned short mapindex;
 	short x = 0, y = 0;
-	int m = -1;
+	int16 m = -1;
 
 	nullpo_retr(-1, sd);
 
@@ -815,7 +815,7 @@ ACMD_FUNC(save)
  *------------------------------------------*/
 ACMD_FUNC(load)
 {
-	int m;
+	int16 m;
 
 	nullpo_retr(-1, sd);
 
@@ -1742,7 +1742,7 @@ ACMD_FUNC(go)
 	int i;
 	int town;
 	char map_name[MAP_NAME_LENGTH];
-	int m;
+	int16 m;
 
 	const struct {
 		char map[MAP_NAME_LENGTH];
@@ -3151,10 +3151,10 @@ ACMD_FUNC(allskill)
  *------------------------------------------*/
 ACMD_FUNC(questskill)
 {
-	int skill_id;
+	uint16 skill_id;
 	nullpo_retr(-1, sd);
 
-	if (!message || !*message || (skill_id = atoi(message)) < 0)
+	if (!message || !*message || (skill_id = atoi(message)) <= 0)
 	{// also send a list of skills applicable to this command
 		const char* text;
 
@@ -3195,10 +3195,10 @@ ACMD_FUNC(questskill)
  *------------------------------------------*/
 ACMD_FUNC(lostskill)
 {
-	int skill_id;
+	uint16 skill_id;
 	nullpo_retr(-1, sd);
 
-	if (!message || !*message || (skill_id = atoi(message)) < 0)
+	if (!message || !*message || (skill_id = atoi(message)) <= 0)
 	{// also send a list of skills applicable to this command
 		const char* text;
 
@@ -5298,13 +5298,13 @@ ACMD_FUNC(clearstorage)
 		clif_displaymessage(fd, msg_txt(250));
 		return -1;
 	}
-	
+
 	j = sd->status.storage.storage_amount;
 	for (i = 0; i < j; ++i) {
 		storage_delitem(sd, i, sd->status.storage.items[i].amount);
 	}
 	storage_storageclose(sd);
-	
+
 	clif_displaymessage(fd, msg_txt(1394)); // Your storage was cleaned.
 	return 0;
 }
@@ -5315,14 +5315,14 @@ ACMD_FUNC(cleargstorage)
 	struct guild *g;
 	struct guild_storage *gstorage;
 	nullpo_retr(-1, sd);
-	
+
 	g = guild_search(sd->status.guild_id);
-	
+
 	if (g == NULL) {
 		clif_displaymessage(fd, msg_txt(43));
 		return -1;
 	}
-	
+
 	if (sd->state.storage_flag == 1) {
 		clif_displaymessage(fd, msg_txt(250));
 		return -1;
@@ -5332,7 +5332,7 @@ ACMD_FUNC(cleargstorage)
 		clif_displaymessage(fd, msg_txt(251));
 		return -1;
 	}
-	
+
 	gstorage = guild2storage2(sd->status.guild_id);
 	if (gstorage == NULL) {// Doesn't have opened @gstorage yet, so we skip the deletion since *shouldn't* have any item there.
 		return -1;
@@ -5345,7 +5345,7 @@ ACMD_FUNC(cleargstorage)
 	}
 	storage_guild_storageclose(sd);
 	gstorage->lock = 0; // Cleaning done, release lock
-	
+
 	clif_displaymessage(fd, msg_txt(1395)); // Your guild storage was cleaned.
 	return 0;
 }
@@ -5354,23 +5354,23 @@ ACMD_FUNC(clearcart)
 {
 	int i;
 	nullpo_retr(-1, sd);
-	
+
 	if (pc_iscarton(sd) == 0) {
 		clif_displaymessage(fd, msg_txt(1396)); // You do not have a cart to be cleaned.
 		return -1;
 	}
-	
+
 	if (sd->state.vending == 1) { //Somehow...
 		return -1;
 	}
-	
+
 	for( i = 0; i < MAX_CART; i++ )
 		if(sd->status.cart[i].nameid > 0)
 			pc_cart_delitem(sd, i, sd->status.cart[i].amount, 1, LOG_TYPE_OTHER);
-	
+
 	clif_clearcart(fd);
 	clif_updatestatus(sd,SP_CARTINFO);
-	
+
 	clif_displaymessage(fd, msg_txt(1397)); // Your cart was cleaned.
 	return 0;
 }
@@ -5411,12 +5411,12 @@ ACMD_FUNC(useskill)
 {
 	struct map_session_data *pl_sd = NULL;
 	struct block_list *bl;
-	int skillnum;
-	int skilllv;
+	uint16 skill_id;
+	uint16 skill_lv;
 	char target[100];
 	nullpo_retr(-1, sd);
 
-	if(!message || !*message || sscanf(message, "%d %d %23[^\n]", &skillnum, &skilllv, target) != 3) {
+	if(!message || !*message || sscanf(message, "%hui %hui %23[^\n]", &skill_id, &skill_lv, target) != 3) {
 		clif_displaymessage(fd, msg_txt(1165)); // Usage: @useskill <skill ID> <skill level> <target>
 		return -1;
 	}
@@ -5433,16 +5433,16 @@ ACMD_FUNC(useskill)
 		return -1;
 	}
 
-	if (skillnum >= HM_SKILLBASE && skillnum < HM_SKILLBASE+MAX_HOMUNSKILL
+	if (skill_id >= HM_SKILLBASE && skill_id < HM_SKILLBASE+MAX_HOMUNSKILL
 		&& sd->hd && merc_is_hom_active(sd->hd)) // (If used with @useskill, put the homunc as dest)
 		bl = &sd->hd->bl;
 	else
 		bl = &sd->bl;
 
-	if (skill_get_inf(skillnum)&INF_GROUND_SKILL)
-		unit_skilluse_pos(bl, pl_sd->bl.x, pl_sd->bl.y, skillnum, skilllv);
+	if (skill_get_inf(skill_id)&INF_GROUND_SKILL)
+		unit_skilluse_pos(bl, pl_sd->bl.x, pl_sd->bl.y, skill_id, skill_lv);
 	else
-		unit_skilluse_id(bl, pl_sd->bl.id, skillnum, skilllv);
+		unit_skilluse_id(bl, pl_sd->bl.id, skill_id, skill_lv);
 
 	return 0;
 }
@@ -5456,20 +5456,20 @@ ACMD_FUNC(displayskill)
 {
 	struct status_data * status;
 	unsigned int tick;
-	int skillnum;
-	int skilllv = 1;
+	uint16 skill_id;
+	uint16 skill_lv = 1;
 	nullpo_retr(-1, sd);
 
-	if (!message || !*message || sscanf(message, "%d %d", &skillnum, &skilllv) < 1)
+	if (!message || !*message || sscanf(message, "%hui %hui", &skill_id, &skill_lv) < 1)
 	{
 		clif_displaymessage(fd, msg_txt(1166)); // Usage: @displayskill <skill ID> {<skill level>}
 		return -1;
 	}
 	status = status_get_status_data(&sd->bl);
 	tick = gettick();
-	clif_skill_damage(&sd->bl,&sd->bl, tick, status->amotion, status->dmotion, 1, 1, skillnum, skilllv, 5);
-	clif_skill_nodamage(&sd->bl, &sd->bl, skillnum, skilllv, 1);
-	clif_skill_poseffect(&sd->bl, skillnum, skilllv, sd->bl.x, sd->bl.y, tick);
+	clif_skill_damage(&sd->bl,&sd->bl, tick, status->amotion, status->dmotion, 1, 1, skill_id, skill_lv, 5);
+	clif_skill_nodamage(&sd->bl, &sd->bl, skill_id, skill_lv, 1);
+	clif_skill_poseffect(&sd->bl, skill_id, skill_lv, sd->bl.x, sd->bl.y, tick);
 	return 0;
 }
 
@@ -5480,13 +5480,13 @@ ACMD_FUNC(displayskill)
 ACMD_FUNC(skilltree)
 {
 	struct map_session_data *pl_sd = NULL;
-	int skillnum;
+	uint16 skill_id;
 	int meets, j, c=0;
 	char target[NAME_LENGTH];
 	struct skill_tree_entry *ent;
 	nullpo_retr(-1, sd);
 
-	if(!message || !*message || sscanf(message, "%d %23[^\r\n]", &skillnum, target) != 2) {
+	if(!message || !*message || sscanf(message, "%hui %23[^\r\n]", &skill_id, target) != 2) {
 		clif_displaymessage(fd, msg_txt(1167)); // Usage: @skilltree <skill ID> <target>
 		return -1;
 	}
@@ -5503,7 +5503,7 @@ ACMD_FUNC(skilltree)
 	sprintf(atcmd_output, msg_txt(1168), job_name(c), pc_checkskill(pl_sd, NV_BASIC)); // Player is using %s skill tree (%d basic points).
 	clif_displaymessage(fd, atcmd_output);
 
-	ARR_FIND( 0, MAX_SKILL_TREE, j, skill_tree[c][j].id == 0 || skill_tree[c][j].id == skillnum );
+	ARR_FIND( 0, MAX_SKILL_TREE, j, skill_tree[c][j].id == 0 || skill_tree[c][j].id == skill_id );
 	if( j == MAX_SKILL_TREE || skill_tree[c][j].id == 0 )
 	{
 		clif_displaymessage(fd, msg_txt(1169)); // The player cannot use that skill.
@@ -7591,16 +7591,16 @@ ACMD_FUNC(mapflag) {
 #define setflag( cmd ) \
 	if ( strcmp( flag_name , #cmd ) == 0 ){\
 		map[ sd->bl.m ].flag.cmd = flag;\
-		sprintf(atcmd_output,"[ @mapflag ] %s flag has been set to %s",#cmd,flag?"On":"Off");\
+		sprintf(atcmd_output,"[ @mapflag ] %s flag has been set to %s value = %hd",#cmd,flag?"On":"Off",flag);\
 		clif_displaymessage(sd->fd,atcmd_output);\
 		return 0;\
 	}
-    unsigned char flag_name[100];
-	int flag=0,i;
+        char flag_name[100];
+	short flag=0,i;
 	nullpo_retr(-1, sd);
 	memset(flag_name, '\0', sizeof(flag_name));
 
-	if (!message || !*message || (sscanf(message, "%99s %d", flag_name, &flag) < 1)) {
+	if (!message || !*message || (sscanf(message, "%99s %hd", flag_name, &flag) < 1)) {
 		clif_displaymessage(sd->fd,msg_txt(1311)); // Enabled Mapflags in this map:
 		clif_displaymessage(sd->fd,"----------------------------------");
 		checkflag(autotrade);			checkflag(allowks);				checkflag(nomemo);		checkflag(noteleport);
@@ -7620,7 +7620,7 @@ ACMD_FUNC(mapflag) {
 		clif_displaymessage(sd->fd,msg_txt(1313)); // Type "@mapflag available" to list the available mapflags.
 		return 1;
 	}
-	for (i = 0; flag_name[i]; i++) flag_name[i] = tolower(flag_name[i]); //lowercase
+	for (i = 0; flag_name[i]; i++) flag_name[i] = (char)tolower(flag_name[i]); //lowercase
 
 	setflag(autotrade);			setflag(allowks);			setflag(nomemo);			setflag(noteleport);
 	setflag(noreturn);			setflag(monster_noteleport);setflag(nosave);			setflag(nobranch);

src/map/battle.h

@@ -33,9 +33,9 @@ struct block_list;
 
 // Damage Calculation
 
-struct Damage battle_calc_attack(int attack_type,struct block_list *bl,struct block_list *target,int skill_num,int skill_lv,int count);
+struct Damage battle_calc_attack(int attack_type,struct block_list *bl,struct block_list *target,uint16 skill_id,uint16 skill_lv,int count);
 
-int battle_calc_return_damage(struct block_list *bl, struct block_list *src, int *, int flag, int skillid);
+int battle_calc_return_damage(struct block_list *bl, struct block_list *src, int *, int flag, uint16 skill_id);
 
 void battle_drain(struct map_session_data *sd, struct block_list *tbl, int rdamage, int ldamage, int race, int boss);
 
@@ -44,9 +44,9 @@ int battle_attr_fix(struct block_list *src, struct block_list *target, int damag
 int battle_calc_cardfix(int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int damage, int left, int flag);
 
 // Final calculation Damage
-int battle_calc_damage(struct block_list *src,struct block_list *bl,struct Damage *d,int damage,int skill_num,int skill_lv);
-int battle_calc_gvg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,int skill_num,int skill_lv,int flag);
-int battle_calc_bg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,int skill_num,int skill_lv,int flag);
+int battle_calc_damage(struct block_list *src,struct block_list *bl,struct Damage *d,int damage,uint16 skill_id,uint16 skill_lv);
+int battle_calc_gvg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,uint16 skill_id,uint16 skill_lv,int flag);
+int battle_calc_bg_damage(struct block_list *src,struct block_list *bl,int damage,int div_,uint16 skill_id,uint16 skill_lv,int flag);
 
 enum {	// Flag of the final calculation
 	BF_WEAPON	= 0x0001,
@@ -61,7 +61,7 @@ enum {	// Flag of the final calculation
 	BF_SKILLMASK= 0x0f00,
 };
 
-int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, int skill_id, int skill_lv, int damage, enum damage_lv dmg_lv, int ddelay);
+int battle_delay_damage (unsigned int tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int damage, enum damage_lv dmg_lv, int ddelay);
 
 // Summary normal attack treatment (basic attack)
 enum damage_lv battle_weapon_attack( struct block_list *bl,struct block_list *target,unsigned int tick,int flag);
@@ -312,8 +312,8 @@ extern struct Battle_Config
 	int pk_level_range;
 
 	int manner_system; // end additions [Valaris]
-	int show_mob_info; 
-	
+	int show_mob_info;
+
 	int gx_allhit;
 	int gx_disptype;
 	int devotion_level_difference;
@@ -336,7 +336,7 @@ extern struct Battle_Config
 	int night_duration; // added by [Yor]
 	int ban_hack_trade; // added by [Yor]
 	int packet_ver_flag; // added by [Yor]
-	
+
 	int min_hair_style; // added by [MouseJstr]
 	int max_hair_style; // added by [MouseJstr]
 	int min_hair_color; // added by [MouseJstr]
@@ -349,7 +349,7 @@ extern struct Battle_Config
 	int area_size; // added by [MouseJstr]
 
 	int max_def, over_def_bonus; //added by [Skotlex]
-	
+
 	int zeny_from_mobs; // [Valaris]
 	int mobs_level_up; // [Valaris]
 	int mobs_level_up_exp_rate; // [Valaris]
@@ -404,7 +404,7 @@ extern struct Battle_Config
 	int duel_autoleave_when_die; // [LuzZza]
 	int duel_time_interval; // [LuzZza]
 	int duel_only_on_same_map; // [Toms]
-	
+
 	int skip_teleport_lv1_menu; // possibility to disable (skip) Teleport Lv1 menu, that have only two lines `Random` and `Cancel` [LuzZza]
 
 	int allow_skill_without_day; // [Komurka]
@@ -477,11 +477,11 @@ extern struct Battle_Config
 	int vcast_stat_scale;
 
 	int mvp_tomb_enabled;
-	
+
 	int atcommand_suggestions_enabled;
     int min_npc_vending_distance;
 	int atcommand_mobinfo_type;
-	
+
 	int mob_size_influence; // Enable modifications on earned experience, drop rates and monster status depending on monster size. [mkbu95]
 } battle_config;
 

src/map/clif.c

@@ -1268,7 +1268,8 @@ static void clif_talisman_single(int fd, struct map_session_data *sd, short type
  *------------------------------------------*/
 static void clif_weather_check(struct map_session_data *sd)
 {
-	int m = sd->bl.m, fd = sd->fd;
+	int16 m = sd->bl.m;
+	int fd = sd->fd;
 
 	if (map[m].flag.snow
 		|| map[m].flag.clouds
@@ -1309,7 +1310,7 @@ static void clif_weather_check(struct map_session_data *sd)
 /**
  * Run when the weather on a map changes, throws all players in map id 'm' to clif_weather_check function
  **/
-void clif_weather(int m)
+void clif_weather(int16 m)
 {
 	struct s_mapiterator* iter;
 	struct map_session_data *sd=NULL;
@@ -1524,23 +1525,23 @@ int clif_homskillinfoblock(struct map_session_data *sd)
 	return 0;
 }
 
-void clif_homskillup(struct map_session_data *sd, int skill_num)
+void clif_homskillup(struct map_session_data *sd, uint16 skill_id)
 {	//[orn]
 	struct homun_data *hd;
-	int fd, skillid;
+	int fd, idx;
 	nullpo_retv(sd);
-	skillid = skill_num - HM_SKILLBASE;
+	idx = skill_id - HM_SKILLBASE;
 
 	fd=sd->fd;
 	hd=sd->hd;
 
 	WFIFOHEAD(fd, packet_len(0x239));
 	WFIFOW(fd,0) = 0x239;
-	WFIFOW(fd,2) = skill_num;
-	WFIFOW(fd,4) = hd->homunculus.hskill[skillid].lv;
-	WFIFOW(fd,6) = skill_get_sp(skill_num,hd->homunculus.hskill[skillid].lv);
-	WFIFOW(fd,8) = skill_get_range2(&hd->bl, skill_num,hd->homunculus.hskill[skillid].lv);
-	WFIFOB(fd,10) = (hd->homunculus.hskill[skillid].lv < skill_get_max(hd->homunculus.hskill[skillid].id)) ? 1 : 0;
+	WFIFOW(fd,2) = skill_id;
+	WFIFOW(fd,4) = hd->homunculus.hskill[idx].lv;
+	WFIFOW(fd,6) = skill_get_sp(skill_id,hd->homunculus.hskill[idx].lv);
+	WFIFOW(fd,8) = skill_get_range2(&hd->bl, skill_id,hd->homunculus.hskill[idx].lv);
+	WFIFOB(fd,10) = (hd->homunculus.hskill[idx].lv < skill_get_max(hd->homunculus.hskill[idx].id)) ? 1 : 0;
 	WFIFOSET(fd,packet_len(0x239));
 }
 
@@ -4336,7 +4337,7 @@ void clif_standing(struct block_list* bl)
 
 /// Inform client(s) about a map-cell change (ZC_UPDATE_MAPINFO).
 /// 0192 <x>.W <y>.W <type>.W <map name>.16B
-void clif_changemapcell(int fd, int m, int x, int y, int type, enum send_target target)
+void clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_target target)
 {
 	unsigned char buf[32];
 
@@ -4705,7 +4706,7 @@ void clif_deleteskill(struct map_session_data *sd, int id)
 
 /// Updates a skill in the skill tree (ZC_SKILLINFO_UPDATE).
 /// 010e <skill id>.W <level>.W <sp cost>.W <attack range>.W <upgradable>.B
-void clif_skillup(struct map_session_data *sd,int skill_num)
+void clif_skillup(struct map_session_data *sd,uint16 skill_id)
 {
 	int fd;
 
@@ -4714,11 +4715,11 @@ void clif_skillup(struct map_session_data *sd,int skill_num)
 	fd=sd->fd;
 	WFIFOHEAD(fd,packet_len(0x10e));
 	WFIFOW(fd,0) = 0x10e;
-	WFIFOW(fd,2) = skill_num;
-	WFIFOW(fd,4) = sd->status.skill[skill_num].lv;
-	WFIFOW(fd,6) = skill_get_sp(skill_num,sd->status.skill[skill_num].lv);
-	WFIFOW(fd,8) = skill_get_range2(&sd->bl,skill_num,sd->status.skill[skill_num].lv);
-	WFIFOB(fd,10) = (sd->status.skill[skill_num].lv < skill_tree_get_max(sd->status.skill[skill_num].id, sd->status.class_)) ? 1 : 0;
+	WFIFOW(fd,2) = skill_id;
+	WFIFOW(fd,4) = sd->status.skill[skill_id].lv;
+	WFIFOW(fd,6) = skill_get_sp(skill_id,sd->status.skill[skill_id].lv);
+	WFIFOW(fd,8) = skill_get_range2(&sd->bl,skill_id,sd->status.skill[skill_id].lv);
+	WFIFOB(fd,10) = (sd->status.skill[skill_id].lv < skill_tree_get_max(sd->status.skill[skill_id].id, sd->status.class_)) ? 1 : 0;
 	WFIFOSET(fd,packet_len(0x10e));
 }
 
@@ -4759,7 +4760,7 @@ void clif_skillinfo(struct map_session_data *sd,int skill, int inf)
 /// is disposable:
 ///     0 = yellow chat text "[src name] will use skill [skill name]."
 ///     1 = no text
-void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x, int dst_y, int skill_num, int property, int casttime)
+void 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)
 {
 #if PACKETVER < 20091124
 	const int cmd = 0x13e;
@@ -4773,7 +4774,7 @@ void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x,
 	WBUFL(buf,6) = dst_id;
 	WBUFW(buf,10) = dst_x;
 	WBUFW(buf,12) = dst_y;
-	WBUFW(buf,14) = skill_num;
+	WBUFW(buf,14) = skill_id;
 	WBUFL(buf,16) = property<0?0:property; //Avoid sending negatives as element [Skotlex]
 	WBUFL(buf,20) = casttime;
 #if PACKETVER >= 20091124
@@ -4826,7 +4827,7 @@ void clif_skillcastcancel(struct block_list* bl)
 /// if(result!=0) doesn't display any of the previous messages
 /// Note: when this packet is received an unknown flag is always set to 0,
 /// suggesting this is an ACK packet for the UseSkill packets and should be sent on success too [FlavioJS]
-void clif_skill_fail(struct map_session_data *sd,int skill_id,enum useskill_fail_cause cause,int btype)
+void clif_skill_fail(struct map_session_data *sd,uint16 skill_id,enum useskill_fail_cause cause,int btype)
 {
 	int fd;
 
@@ -4862,7 +4863,7 @@ void clif_skill_fail(struct map_session_data *sd,int skill_id,enum useskill_fail
 
 /// Skill cooldown display icon (ZC_SKILL_POSTDELAY).
 /// 043d <skill ID>.W <tick>.L
-void clif_skill_cooldown(struct map_session_data *sd, int skillid, unsigned int tick)
+void clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int tick)
 {
 #if PACKETVER>=20081112
 	int fd;
@@ -4872,7 +4873,7 @@ void clif_skill_cooldown(struct map_session_data *sd, int skillid, unsigned int
 	fd=sd->fd;
 	WFIFOHEAD(fd,packet_len(0x43d));
 	WFIFOW(fd,0) = 0x43d;
-	WFIFOW(fd,2) = skillid;
+	WFIFOW(fd,2) = skill_id;
 	WFIFOL(fd,4) = tick;
 	WFIFOSET(fd,packet_len(0x43d));
 #endif
@@ -4882,7 +4883,7 @@ void clif_skill_cooldown(struct map_session_data *sd, int skillid, unsigned int
 /// Skill attack effect and damage.
 /// 0114 <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <damage>.W <level>.W <div>.W <type>.B (ZC_NOTIFY_SKILL)
 /// 01de <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <damage>.L <level>.W <div>.W <type>.B (ZC_NOTIFY_SKILL2)
-int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,int skill_id,int skill_lv,int type)
+int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type)
 {
 	unsigned char buf[64];
 	struct status_change *sc;
@@ -4969,7 +4970,7 @@ int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int
 /// Ground skill attack effect and damage (ZC_NOTIFY_SKILL_POSITION).
 /// 0115 <skill id>.W <src id>.L <dst id>.L <tick>.L <src delay>.L <dst delay>.L <x>.W <y>.W <damage>.W <level>.W <div>.W <type>.B
 /*
-int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,int skill_id,int skill_lv,int type)
+int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type)
 {
 	unsigned char buf[64];
 	struct status_change *sc;
@@ -5027,7 +5028,7 @@ int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned in
 
 /// Non-damaging skill effect (ZC_USE_SKILL).
 /// 011a <skill id>.W <skill lv>.W <dst id>.L <src id>.L <result>.B
-int clif_skill_nodamage(struct block_list *src,struct block_list *dst,int skill_id,int heal,int fail)
+int clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 skill_id,int heal,int fail)
 {
 	unsigned char buf[32];
 
@@ -5060,7 +5061,7 @@ int clif_skill_nodamage(struct block_list *src,struct block_list *dst,int skill_
 
 /// Non-damaging ground skill effect (ZC_NOTIFY_GROUNDSKILL).
 /// 0117 <skill id>.W <src id>.L <level>.W <x>.W <y>.W <tick>.L
-void clif_skill_poseffect(struct block_list *src,int skill_id,int val,int x,int y,int tick)
+void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,int y,int tick)
 {
 	unsigned char buf[32];
 
@@ -5128,7 +5129,7 @@ void clif_skill_setunit(struct skill_unit *unit)
 
 /// Presents a list of available warp destinations (ZC_WARPLIST).
 /// 011c <skill id>.W { <map name>.16B }*4
-void clif_skill_warppoint(struct map_session_data* sd, short skill_num, short skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4)
+void 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 fd;
 	nullpo_retv(sd);
@@ -5136,7 +5137,7 @@ void clif_skill_warppoint(struct map_session_data* sd, short skill_num, short sk
 
 	WFIFOHEAD(fd,packet_len(0x11c));
 	WFIFOW(fd,0) = 0x11c;
-	WFIFOW(fd,2) = skill_num;
+	WFIFOW(fd,2) = skill_id;
 	memset(WFIFOP(fd,4), 0x00, 4*MAP_NAME_LENGTH_EXT);
 	if (map1 == (unsigned short)-1) strcpy((char*)WFIFOP(fd,4), "Random");
 	else // normal map name
@@ -5146,8 +5147,8 @@ void clif_skill_warppoint(struct map_session_data* sd, short skill_num, short sk
 	if (map4 > 0) mapindex_getmapname_ext(mapindex_id2name(map4), (char*)WFIFOP(fd,52));
 	WFIFOSET(fd,packet_len(0x11c));
 
-	sd->menuskill_id = skill_num;
-	if (skill_num == AL_WARP)
+	sd->menuskill_id = skill_id;
+	if (skill_id == AL_WARP)
 		sd->menuskill_val = (sd->ud.skillx<<16)|sd->ud.skilly; //Store warp position here.
 	else
 		sd->menuskill_val = skill_lv;
@@ -5240,15 +5241,15 @@ void clif_skill_estimation(struct map_session_data *sd,struct block_list *dst)
 /// 018d <packet len>.W { <name id>.W { <material id>.W }*3 }*
 /// material id:
 ///     unused by the client
-void clif_skill_produce_mix_list(struct map_session_data *sd, int skillid , int trigger)
+void clif_skill_produce_mix_list(struct map_session_data *sd, uint16 skill_id , int trigger)
 {
 	int i,c,view,fd;
 	nullpo_retv(sd);
 
-	if(sd->menuskill_id == skillid)
+	if(sd->menuskill_id == skill_id)
 		return; //Avoid resending the menu twice or more times...
-	if( skillid == GC_CREATENEWPOISON )
-		skillid = GC_RESEARCHNEWPOISON;
+	if( skill_id == GC_CREATENEWPOISON )
+		skill_id = GC_RESEARCHNEWPOISON;
 
 	fd=sd->fd;
 	WFIFOHEAD(fd, MAX_SKILL_PRODUCE_DB * 8 + 8);
@@ -5256,7 +5257,7 @@ void clif_skill_produce_mix_list(struct map_session_data *sd, int skillid , int
 
 	for(i=0,c=0;i<MAX_SKILL_PRODUCE_DB;i++){
 		if( skill_can_produce_mix(sd,skill_produce_db[i].nameid, trigger, 1) &&
-			( ( skillid > 0 && skill_produce_db[i].req_skill == skillid ) || skillid < 0 )
+			( ( skill_id > 0 && skill_produce_db[i].req_skill == skill_id ) || skill_id < 0 )
 			){
 			if((view = itemdb_viewid(skill_produce_db[i].nameid)) > 0)
 				WFIFOW(fd,c*8+ 4)= view;
@@ -5271,7 +5272,7 @@ void clif_skill_produce_mix_list(struct map_session_data *sd, int skillid , int
 	WFIFOW(fd, 2)=c*8+8;
 	WFIFOSET(fd,WFIFOW(fd,2));
 	if(c > 0) {
-		sd->menuskill_id = skillid;
+		sd->menuskill_id = skill_id;
 		sd->menuskill_val = trigger;
 		return;
 	}
@@ -5287,7 +5288,7 @@ void clif_skill_produce_mix_list(struct map_session_data *sd, int skillid , int
 ///     4 = GN_MIX_COOKING
 ///     5 = GN_MAKEBOMB
 ///     6 = GN_S_PHARMACY
-void clif_cooking_list(struct map_session_data *sd, int trigger, int skill_id, int qty, int list_type)
+void clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type)
 {
 	int fd;
 	int i, c;
@@ -5853,7 +5854,7 @@ void clif_item_repair_list(struct map_session_data *sd,struct map_session_data *
 		sd->menuskill_val = dstsd->bl.id;
 		sd->menuskill_val2 = lv;
 	}else
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 }
 
 
@@ -5901,13 +5902,13 @@ void clif_item_refine_list(struct map_session_data *sd)
 {
 	int i,c;
 	int fd;
-	int skilllv;
+	uint16 skill_lv;
 	int wlv;
 	int refine_item[5];
 
 	nullpo_retv(sd);
 
-	skilllv = pc_checkskill(sd,WS_WEAPONREFINE);
+	skill_lv = pc_checkskill(sd,WS_WEAPONREFINE);
 
 	fd=sd->fd;
 
@@ -5919,7 +5920,7 @@ void clif_item_refine_list(struct map_session_data *sd)
 	WFIFOHEAD(fd, MAX_INVENTORY * 13 + 4);
 	WFIFOW(fd,0)=0x221;
 	for(i=c=0;i<MAX_INVENTORY;i++){
-		if(sd->status.inventory[i].nameid > 0 && sd->status.inventory[i].refine < skilllv &&
+		if(sd->status.inventory[i].nameid > 0 && sd->status.inventory[i].refine < skill_lv &&
 			sd->status.inventory[i].identify && (wlv=itemdb_wlv(sd->status.inventory[i].nameid)) >=1 &&
 			refine_item[wlv]!=-1 && !(sd->status.inventory[i].equip&EQP_ARMS)){
 			WFIFOW(fd,c*13+ 4)=i+2;
@@ -5933,14 +5934,14 @@ void clif_item_refine_list(struct map_session_data *sd)
 	WFIFOSET(fd,WFIFOW(fd,2));
 	if (c > 0) {
 		sd->menuskill_id = WS_WEAPONREFINE;
-		sd->menuskill_val = skilllv;
+		sd->menuskill_val = skill_lv;
 	}
 }
 
 
 /// Notification of an auto-casted skill (ZC_AUTORUN_SKILL).
 /// 0147 <skill id>.W <type>.L <level>.W <sp cost>.W <atk range>.W <skill name>.24B <upgradable>.B
-void clif_item_skill(struct map_session_data *sd,int skillid,int skilllv)
+void clif_item_skill(struct map_session_data *sd,uint16 skill_id,uint16 skill_lv)
 {
 	int fd;
 
@@ -5949,13 +5950,13 @@ void clif_item_skill(struct map_session_data *sd,int skillid,int skilllv)
 	fd=sd->fd;
 	WFIFOHEAD(fd,packet_len(0x147));
 	WFIFOW(fd, 0)=0x147;
-	WFIFOW(fd, 2)=skillid;
-	WFIFOW(fd, 4)=skill_get_inf(skillid);
+	WFIFOW(fd, 2)=skill_id;
+	WFIFOW(fd, 4)=skill_get_inf(skill_id);
 	WFIFOW(fd, 6)=0;
-	WFIFOW(fd, 8)=skilllv;
-	WFIFOW(fd,10)=skill_get_sp(skillid,skilllv);
-	WFIFOW(fd,12)=skill_get_range2(&sd->bl, skillid,skilllv);
-	safestrncpy((char*)WFIFOP(fd,14),skill_get_name(skillid),NAME_LENGTH);
+	WFIFOW(fd, 8)=skill_lv;
+	WFIFOW(fd,10)=skill_get_sp(skill_id,skill_lv);
+	WFIFOW(fd,12)=skill_get_range2(&sd->bl, skill_id,skill_lv);
+	safestrncpy((char*)WFIFOP(fd,14),skill_get_name(skill_id),NAME_LENGTH);
 	WFIFOB(fd,38)=0;
 	WFIFOSET(fd,packet_len(0x147));
 }
@@ -6816,7 +6817,7 @@ void clif_pet_food(struct map_session_data *sd,int foodid,int fail)
 
 /// Presents a list of skills that can be auto-spelled (ZC_AUTOSPELLLIST).
 /// 01cd { <skill id>.L }*7
-void clif_autospell(struct map_session_data *sd,int skilllv)
+void clif_autospell(struct map_session_data *sd,uint16 skill_lv)
 {
 	int fd;
 
@@ -6826,38 +6827,38 @@ void clif_autospell(struct map_session_data *sd,int skilllv)
 	WFIFOHEAD(fd,packet_len(0x1cd));
 	WFIFOW(fd, 0)=0x1cd;
 
-	if(skilllv>0 && pc_checkskill(sd,MG_NAPALMBEAT)>0)
+	if(skill_lv>0 && pc_checkskill(sd,MG_NAPALMBEAT)>0)
 		WFIFOL(fd,2)= MG_NAPALMBEAT;
 	else
 		WFIFOL(fd,2)= 0x00000000;
-	if(skilllv>1 && pc_checkskill(sd,MG_COLDBOLT)>0)
+	if(skill_lv>1 && pc_checkskill(sd,MG_COLDBOLT)>0)
 		WFIFOL(fd,6)= MG_COLDBOLT;
 	else
 		WFIFOL(fd,6)= 0x00000000;
-	if(skilllv>1 && pc_checkskill(sd,MG_FIREBOLT)>0)
+	if(skill_lv>1 && pc_checkskill(sd,MG_FIREBOLT)>0)
 		WFIFOL(fd,10)= MG_FIREBOLT;
 	else
 		WFIFOL(fd,10)= 0x00000000;
-	if(skilllv>1 && pc_checkskill(sd,MG_LIGHTNINGBOLT)>0)
+	if(skill_lv>1 && pc_checkskill(sd,MG_LIGHTNINGBOLT)>0)
 		WFIFOL(fd,14)= MG_LIGHTNINGBOLT;
 	else
 		WFIFOL(fd,14)= 0x00000000;
-	if(skilllv>4 && pc_checkskill(sd,MG_SOULSTRIKE)>0)
+	if(skill_lv>4 && pc_checkskill(sd,MG_SOULSTRIKE)>0)
 		WFIFOL(fd,18)= MG_SOULSTRIKE;
 	else
 		WFIFOL(fd,18)= 0x00000000;
-	if(skilllv>7 && pc_checkskill(sd,MG_FIREBALL)>0)
+	if(skill_lv>7 && pc_checkskill(sd,MG_FIREBALL)>0)
 		WFIFOL(fd,22)= MG_FIREBALL;
 	else
 		WFIFOL(fd,22)= 0x00000000;
-	if(skilllv>9 && pc_checkskill(sd,MG_FROSTDIVER)>0)
+	if(skill_lv>9 && pc_checkskill(sd,MG_FROSTDIVER)>0)
 		WFIFOL(fd,26)= MG_FROSTDIVER;
 	else
 		WFIFOL(fd,26)= 0x00000000;
 
 	WFIFOSET(fd,packet_len(0x1cd));
 	sd->menuskill_id = SA_AUTOSPELL;
-	sd->menuskill_val = skilllv;
+	sd->menuskill_val = skill_lv;
 }
 
 
@@ -7632,9 +7633,9 @@ void clif_guild_message(struct guild *g,int account_id,const char *mes,int len)
 
 
 /*==========================================
- * Server tells client 'sd' that his guild skill 'skill_num' gone to level 'lv'
+ * Server tells client 'sd' that his guild skill 'skill_id' gone to level 'lv'
  *------------------------------------------*/
-int clif_guild_skillup(struct map_session_data *sd,int skill_num,int lv)
+int clif_guild_skillup(struct map_session_data *sd,uint16 skill_id,int lv)
 {// TODO: Merge with clif_skillup (same packet).
 	int fd;
 
@@ -7643,10 +7644,10 @@ int clif_guild_skillup(struct map_session_data *sd,int skill_num,int lv)
 	fd=sd->fd;
 	WFIFOHEAD(fd,11);
 	WFIFOW(fd,0) = 0x10e;
-	WFIFOW(fd,2) = skill_num;
+	WFIFOW(fd,2) = skill_id;
 	WFIFOW(fd,4) = lv;
-	WFIFOW(fd,6) = skill_get_sp(skill_num,lv);
-	WFIFOW(fd,8) = skill_get_range(skill_num,lv);
+	WFIFOW(fd,6) = skill_get_sp(skill_id,lv);
+	WFIFOW(fd,8) = skill_get_range(skill_id,lv);
 	WFIFOB(fd,10) = 1;
 	WFIFOSET(fd,11);
 	return 0;
@@ -8807,7 +8808,7 @@ void clif_msg_value(struct map_session_data* sd, unsigned short id, int value)
 ///
 /// NOTE: Message has following format and is printed in color 0xCDCDFF (purple):
 ///       "[SkillName] Message"
-void clif_msg_skill(struct map_session_data* sd, unsigned short skill_id, int msg_id)
+void clif_msg_skill(struct map_session_data* sd, uint16 skill_id, int msg_id)
 {
 	int fd = sd->fd;
 
@@ -10663,97 +10664,97 @@ void clif_parse_SkillUp(int fd,struct map_session_data *sd)
 	pc_skillup(sd,RFIFOW(fd,2));
 }
 
-static void clif_parse_UseSkillToId_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, short skillnum, short skilllv, int target_id)
+static void clif_parse_UseSkillToId_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, int target_id)
 {
 	int lv;
 
 	if( !hd )
 		return;
-	if( skillnotok_hom(skillnum, hd) )
+	if( skillnotok_hom(skill_id, hd) )
 		return;
-	if( hd->bl.id != target_id && skill_get_inf(skillnum)&INF_SELF_SKILL )
+	if( hd->bl.id != target_id && skill_get_inf(skill_id)&INF_SELF_SKILL )
 		target_id = hd->bl.id;
 	if( hd->ud.skilltimer != INVALID_TIMER )
 	{
-		if( skillnum != SA_CASTCANCEL && skillnum != SO_SPELLFIST ) return;
+		if( skill_id != SA_CASTCANCEL && skill_id != SO_SPELLFIST ) return;
 	}
 	else if( DIFF_TICK(tick, hd->ud.canact_tick) < 0 )
 		return;
 
-	lv = merc_hom_checkskill(hd, skillnum);
-	if( skilllv > lv )
-		skilllv = lv;
-	if( skilllv )
-		unit_skilluse_id(&hd->bl, target_id, skillnum, skilllv);
+	lv = merc_hom_checkskill(hd, skill_id);
+	if( skill_lv > lv )
+		skill_lv = lv;
+	if( skill_lv )
+		unit_skilluse_id(&hd->bl, target_id, skill_id, skill_lv);
 }
 
-static void clif_parse_UseSkillToPos_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, short skillnum, short skilllv, short x, short y, int skillmoreinfo)
+static void clif_parse_UseSkillToPos_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo)
 {
 	int lv;
 	if( !hd )
 		return;
-	if( skillnotok_hom(skillnum, hd) )
+	if( skillnotok_hom(skill_id, hd) )
 		return;
 	if( hd->ud.skilltimer != INVALID_TIMER ) {
-		if( skillnum != SA_CASTCANCEL && skillnum != SO_SPELLFIST ) return;
+		if( skill_id != SA_CASTCANCEL && skill_id != SO_SPELLFIST ) return;
 	} else if( DIFF_TICK(tick, hd->ud.canact_tick) < 0 )
 		return;
 
 	if( hd->sc.data[SC_BASILICA] )
 		return;
-	lv = merc_hom_checkskill(hd, skillnum);
-	if( skilllv > lv )
-		skilllv = lv;
-	if( skilllv )
-		unit_skilluse_pos(&hd->bl, x, y, skillnum, skilllv);
+	lv = merc_hom_checkskill(hd, skill_id);
+	if( skill_lv > lv )
+		skill_lv = lv;
+	if( skill_lv )
+		unit_skilluse_pos(&hd->bl, x, y, skill_id, skill_lv);
 }
 
-static void clif_parse_UseSkillToId_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, short skillnum, short skilllv, int target_id)
+static void clif_parse_UseSkillToId_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, int target_id)
 {
 	int lv;
 
 	if( !md )
 		return;
-	if( skillnotok_mercenary(skillnum, md) )
+	if( skillnotok_mercenary(skill_id, md) )
 		return;
-	if( md->bl.id != target_id && skill_get_inf(skillnum)&INF_SELF_SKILL )
+	if( md->bl.id != target_id && skill_get_inf(skill_id)&INF_SELF_SKILL )
 		target_id = md->bl.id;
 	if( md->ud.skilltimer != INVALID_TIMER )
 	{
-		if( skillnum != SA_CASTCANCEL && skillnum != SO_SPELLFIST ) return;
+		if( skill_id != SA_CASTCANCEL && skill_id != SO_SPELLFIST ) return;
 	}
 	else if( DIFF_TICK(tick, md->ud.canact_tick) < 0 )
 		return;
 
-	lv = mercenary_checkskill(md, skillnum);
-	if( skilllv > lv )
-		skilllv = lv;
-	if( skilllv )
-		unit_skilluse_id(&md->bl, target_id, skillnum, skilllv);
+	lv = mercenary_checkskill(md, skill_id);
+	if( skill_lv > lv )
+		skill_lv = lv;
+	if( skill_lv )
+		unit_skilluse_id(&md->bl, target_id, skill_id, skill_lv);
 }
 
-static void clif_parse_UseSkillToPos_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, short skillnum, short skilllv, short x, short y, int skillmoreinfo)
+static void clif_parse_UseSkillToPos_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo)
 {
 	int lv;
 	if( !md )
 		return;
-	if( skillnotok_mercenary(skillnum, md) )
+	if( skillnotok_mercenary(skill_id, md) )
 		return;
 	if( md->ud.skilltimer != INVALID_TIMER )
 		return;
 	if( DIFF_TICK(tick, md->ud.canact_tick) < 0 )
 	{
-		clif_skill_fail(md->master, skillnum, USESKILL_FAIL_SKILLINTERVAL, 0);
+		clif_skill_fail(md->master, skill_id, USESKILL_FAIL_SKILLINTERVAL, 0);
 		return;
 	}
 
 	if( md->sc.data[SC_BASILICA] )
 		return;
-	lv = mercenary_checkskill(md, skillnum);
-	if( skilllv > lv )
-		skilllv = lv;
-	if( skilllv )
-		unit_skilluse_pos(&md->bl, x, y, skillnum, skilllv);
+	lv = mercenary_checkskill(md, skill_id);
+	if( skill_lv > lv )
+		skill_lv = lv;
+	if( skill_lv )
+		unit_skilluse_pos(&md->bl, x, y, skill_id, skill_lv);
 }
 
 
@@ -10763,41 +10764,41 @@ static void clif_parse_UseSkillToPos_mercenary(struct mercenary_data *md, struct
 /// There are various variants of this packet, some of them have padding between fields.
 void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
 {
-	short skillnum, skilllv;
+	uint16 skill_id, skill_lv;
 	int tmp, target_id;
 	unsigned int tick = gettick();
 
-	skilllv = RFIFOW(fd,packet_db[sd->packet_ver][RFIFOW(fd,0)].pos[0]);
-	skillnum = RFIFOW(fd,packet_db[sd->packet_ver][RFIFOW(fd,0)].pos[1]);
+	skill_lv = RFIFOW(fd,packet_db[sd->packet_ver][RFIFOW(fd,0)].pos[0]);
+	skill_id = RFIFOW(fd,packet_db[sd->packet_ver][RFIFOW(fd,0)].pos[1]);
 	target_id = RFIFOL(fd,packet_db[sd->packet_ver][RFIFOW(fd,0)].pos[2]);
 
-	if( skilllv < 1 ) skilllv = 1; //No clue, I have seen the client do this with guild skills :/ [Skotlex]
+	if( skill_lv < 1 ) skill_lv = 1; //No clue, I have seen the client do this with guild skills :/ [Skotlex]
 
-	tmp = skill_get_inf(skillnum);
+	tmp = skill_get_inf(skill_id);
 	if (tmp&INF_GROUND_SKILL || !tmp)
 		return; //Using a ground/passive skill on a target? WRONG.
 
-	if( skillnum >= HM_SKILLBASE && skillnum < HM_SKILLBASE + MAX_HOMUNSKILL )
+	if( skill_id >= HM_SKILLBASE && skill_id < HM_SKILLBASE + MAX_HOMUNSKILL )
 	{
-		clif_parse_UseSkillToId_homun(sd->hd, sd, tick, skillnum, skilllv, target_id);
+		clif_parse_UseSkillToId_homun(sd->hd, sd, tick, skill_id, skill_lv, target_id);
 		return;
 	}
 
-	if( skillnum >= MC_SKILLBASE && skillnum < MC_SKILLBASE + MAX_MERCSKILL )
+	if( skill_id >= MC_SKILLBASE && skill_id < MC_SKILLBASE + MAX_MERCSKILL )
 	{
-		clif_parse_UseSkillToId_mercenary(sd->md, sd, tick, skillnum, skilllv, target_id);
+		clif_parse_UseSkillToId_mercenary(sd->md, sd, tick, skill_id, skill_lv, target_id);
 		return;
 	}
 
 	// Whether skill fails or not is irrelevant, the char ain't idle. [Skotlex]
 	sd->idletime = last_tick;
 
-	if( pc_cant_act(sd) && skillnum != RK_REFRESH && !(skillnum == SR_GENTLETOUCH_CURE && (sd->sc.opt1 == OPT1_STONE || sd->sc.opt1 == OPT1_FREEZE || sd->sc.opt1 == OPT1_STUN)) )
+	if( pc_cant_act(sd) && skill_id != RK_REFRESH && !(skill_id == SR_GENTLETOUCH_CURE && (sd->sc.opt1 == OPT1_STONE || sd->sc.opt1 == OPT1_FREEZE || sd->sc.opt1 == OPT1_STUN)) )
 		return;
 	if( pc_issit(sd) )
 		return;
 
-	if( skillnotok(skillnum, sd) )
+	if( skillnotok(skill_id, sd) )
 		return;
 
 	if( sd->bl.id != target_id && tmp&INF_SELF_SKILL )
@@ -10808,14 +10809,14 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
 
 	if( sd->ud.skilltimer != INVALID_TIMER )
 	{
-		if( skillnum != SA_CASTCANCEL && skillnum != SO_SPELLFIST )
+		if( skill_id != SA_CASTCANCEL && skill_id != SO_SPELLFIST )
 			return;
 	}
 	else if( DIFF_TICK(tick, sd->ud.canact_tick) < 0 )
 	{
-		if( sd->skillitem != skillnum )
+		if( sd->skillitem != skill_id )
 		{
-			clif_skill_fail(sd, skillnum, USESKILL_FAIL_SKILLINTERVAL, 0);
+			clif_skill_fail(sd, skill_id, USESKILL_FAIL_SKILLINTERVAL, 0);
 			return;
 		}
 	}
@@ -10823,7 +10824,7 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
 	if( sd->sc.option&(OPTION_WEDDING|OPTION_XMAS|OPTION_SUMMER) )
 		return;
 
-	if( sd->sc.data[SC_BASILICA] && (skillnum != HP_BASILICA || sd->sc.data[SC_BASILICA]->val4 != sd->bl.id) )
+	if( sd->sc.data[SC_BASILICA] && (skill_id != HP_BASILICA || sd->sc.data[SC_BASILICA]->val4 != sd->bl.id) )
 		return; // On basilica only caster can use Basilica again to stop it.
 
 	if( sd->menuskill_id ) {
@@ -10832,65 +10833,65 @@ void clif_parse_UseSkillToId(int fd, struct map_session_data *sd)
 		} else if( sd->menuskill_id != SA_AUTOSPELL )
 			return; //Can't use skills while a menu is open.
 	}
-	if( sd->skillitem == skillnum ) {
-		if( skilllv != sd->skillitemlv )
-			skilllv = sd->skillitemlv;
+	if( sd->skillitem == skill_id ) {
+		if( skill_lv != sd->skillitemlv )
+			skill_lv = sd->skillitemlv;
 		if( !(tmp&INF_SELF_SKILL) )
 			pc_delinvincibletimer(sd); // Target skills thru items cancel invincibility. [Inkfish]
-		unit_skilluse_id(&sd->bl, target_id, skillnum, skilllv);
+		unit_skilluse_id(&sd->bl, target_id, skill_id, skill_lv);
 		return;
 	}
 
 	sd->skillitem = sd->skillitemlv = 0;
 
-	if( skillnum >= GD_SKILLBASE ) {
+	if( skill_id >= GD_SKILLBASE ) {
 		if( sd->state.gmaster_flag )
-			skilllv = guild_checkskill(sd->state.gmaster_flag, skillnum);
+			skill_lv = guild_checkskill(sd->state.gmaster_flag, skill_id);
 		else
-			skilllv = 0;
+			skill_lv = 0;
 	} else {
-		tmp = pc_checkskill(sd, skillnum);
-		if( skilllv > tmp )
-			skilllv = tmp;
+		tmp = pc_checkskill(sd, skill_id);
+		if( skill_lv > tmp )
+			skill_lv = tmp;
 	}
 
 	pc_delinvincibletimer(sd);
 
-	if( skilllv )
-		unit_skilluse_id(&sd->bl, target_id, skillnum, skilllv);
+	if( skill_lv )
+		unit_skilluse_id(&sd->bl, target_id, skill_id, skill_lv);
 }
 
 /*==========================================
- * Client tells server he'd like to use AoE skill id 'skillnum' of level 'skilllv' on 'x','y' location
+ * Client tells server he'd like to use AoE skill id 'skill_id' of level 'skill_lv' on 'x','y' location
  *------------------------------------------*/
-static void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, short skilllv, short skillnum, short x, short y, int skillmoreinfo)
+static void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo)
 {
 	unsigned int tick = gettick();
 
-	if( !(skill_get_inf(skillnum)&INF_GROUND_SKILL) )
+	if( !(skill_get_inf(skill_id)&INF_GROUND_SKILL) )
 		return; //Using a target skill on the ground? WRONG.
 
-	if( skillnum >= HM_SKILLBASE && skillnum < HM_SKILLBASE + MAX_HOMUNSKILL ) {
-		clif_parse_UseSkillToPos_homun(sd->hd, sd, tick, skillnum, skilllv, x, y, skillmoreinfo);
+	if( skill_id >= HM_SKILLBASE && skill_id < HM_SKILLBASE + MAX_HOMUNSKILL ) {
+		clif_parse_UseSkillToPos_homun(sd->hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
 		return;
 	}
 
-	if( skillnum >= MC_SKILLBASE && skillnum < MC_SKILLBASE + MAX_MERCSKILL )
+	if( skill_id >= MC_SKILLBASE && skill_id < MC_SKILLBASE + MAX_MERCSKILL )
 	{
-		clif_parse_UseSkillToPos_mercenary(sd->md, sd, tick, skillnum, skilllv, x, y, skillmoreinfo);
+		clif_parse_UseSkillToPos_mercenary(sd->md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
 		return;
 	}
 
 	//Whether skill fails or not is irrelevant, the char ain't idle. [Skotlex]
 	sd->idletime = last_tick;
 
-	if( skillnotok(skillnum, sd) )
+	if( skillnotok(skill_id, sd) )
 		return;
 	if( skillmoreinfo != -1 )
 	{
 		if( pc_issit(sd) )
 		{
-			clif_skill_fail(sd, skillnum, USESKILL_FAIL_LEVEL, 0);
+			clif_skill_fail(sd, skill_id, USESKILL_FAIL_LEVEL, 0);
 			return;
 		}
 		//You can't use Graffiti/TalkieBox AND have a vending open, so this is safe.
@@ -10901,8 +10902,8 @@ static void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, sho
 		return;
 
 	if( DIFF_TICK(tick, sd->ud.canact_tick) < 0 ) {
-		if( sd->skillitem != skillnum ) {
-			clif_skill_fail(sd, skillnum, USESKILL_FAIL_SKILLINTERVAL, 0);
+		if( sd->skillitem != skill_id ) {
+			clif_skill_fail(sd, skill_id, USESKILL_FAIL_SKILLINTERVAL, 0);
 			return;
 		}
 	}
@@ -10910,7 +10911,7 @@ static void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, sho
 	if( sd->sc.option&(OPTION_WEDDING|OPTION_XMAS|OPTION_SUMMER) )
 		return;
 
-	if( sd->sc.data[SC_BASILICA] && (skillnum != HP_BASILICA || sd->sc.data[SC_BASILICA]->val4 != sd->bl.id) )
+	if( sd->sc.data[SC_BASILICA] && (skill_id != HP_BASILICA || sd->sc.data[SC_BASILICA]->val4 != sd->bl.id) )
 		return; // On basilica only caster can use Basilica again to stop it.
 
 	if( sd->menuskill_id ) {
@@ -10922,17 +10923,17 @@ static void clif_parse_UseSkillToPosSub(int fd, struct map_session_data *sd, sho
 
 	pc_delinvincibletimer(sd);
 
-	if( sd->skillitem == skillnum ) {
-		if( skilllv != sd->skillitemlv )
-			skilllv = sd->skillitemlv;
-		unit_skilluse_pos(&sd->bl, x, y, skillnum, skilllv);
+	if( sd->skillitem == skill_id ) {
+		if( skill_lv != sd->skillitemlv )
+			skill_lv = sd->skillitemlv;
+		unit_skilluse_pos(&sd->bl, x, y, skill_id, skill_lv);
 	} else {
 		int lv;
 		sd->skillitem = sd->skillitemlv = 0;
-		if( (lv = pc_checkskill(sd, skillnum)) > 0 ) {
-			if( skilllv > lv )
-				skilllv = lv;
-			unit_skilluse_pos(&sd->bl, x, y, skillnum,skilllv);
+		if( (lv = pc_checkskill(sd, skill_id)) > 0 ) {
+			if( skill_lv > lv )
+				skill_lv = lv;
+			unit_skilluse_pos(&sd->bl, x, y, skill_id,skill_lv);
 		}
 	}
 }
@@ -10984,11 +10985,11 @@ void clif_parse_UseSkillToPosMoreInfo(int fd, struct map_session_data *sd)
 /// 011b <skill id>.W <map name>.16B
 void clif_parse_UseSkillMap(int fd, struct map_session_data* sd)
 {
-	short skill_num = RFIFOW(fd,2);
+	uint16 skill_id = RFIFOW(fd,2);
 	char map_name[MAP_NAME_LENGTH];
 	mapindex_getmapname((char*)RFIFOP(fd,4), map_name);
 
-	if(skill_num != sd->menuskill_id)
+	if(skill_id != sd->menuskill_id)
 		return;
 
 	if( pc_cant_act(sd) ) {
@@ -10997,7 +10998,7 @@ void clif_parse_UseSkillMap(int fd, struct map_session_data* sd)
 	}
 
 	pc_delinvincibletimer(sd);
-	skill_castend_map(sd,skill_num,map_name);
+	skill_castend_map(sd,skill_id,map_name);
 }
 
 
@@ -11025,7 +11026,7 @@ void clif_parse_ProduceMix(int fd,struct map_session_data *sd)
 	}
 	if (pc_istrading(sd)) {
 		//Make it fail to avoid shop exploits where you sell something different than you see.
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 		clif_menuskill_clear(sd);
 		return;
 	}
@@ -11053,7 +11054,7 @@ void clif_parse_Cooking(int fd,struct map_session_data *sd) {
 
 	if (pc_istrading(sd)) {
 		//Make it fail to avoid shop exploits where you sell something different than you see.
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 		clif_menuskill_clear(sd);
 		return;
 	}
@@ -11071,7 +11072,7 @@ void clif_parse_RepairItem(int fd, struct map_session_data *sd)
 		return;
 	if (pc_istrading(sd)) {
 		//Make it fail to avoid shop exploits where you sell something different than you see.
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 		clif_menuskill_clear(sd);
 		return;
 	}
@@ -11090,7 +11091,7 @@ void clif_parse_WeaponRefine(int fd, struct map_session_data *sd)
 		return;
 	if (pc_istrading(sd)) {
 		//Make it fail to avoid shop exploits where you sell something different than you see.
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 		clif_menuskill_clear(sd);
 		return;
 	}
@@ -11196,7 +11197,7 @@ void clif_parse_SelectArrow(int fd,struct map_session_data *sd)
 {
 	if (pc_istrading(sd)) {
 	//Make it fail to avoid shop exploits where you sell something different than you see.
-		clif_skill_fail(sd,sd->ud.skillid,USESKILL_FAIL_LEVEL,0);
+		clif_skill_fail(sd,sd->ud.skill_id,USESKILL_FAIL_LEVEL,0);
 		clif_menuskill_clear(sd);
 		return;
 	}
@@ -13340,14 +13341,14 @@ void clif_parse_FeelSaveOk(int fd,struct map_session_data *sd)
 ///     0 = sun
 ///     1 = moon
 ///     2 = star
-void clif_feel_req(int fd, struct map_session_data *sd, int skilllv)
+void clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv)
 {
 	WFIFOHEAD(fd,packet_len(0x253));
 	WFIFOW(fd,0)=0x253;
-	WFIFOB(fd,2)=TOB(skilllv-1);
+	WFIFOB(fd,2)=TOB(skill_lv-1);
 	WFIFOSET(fd, packet_len(0x253));
 	sd->menuskill_id = SG_FEEL;
-	sd->menuskill_val = skilllv;
+	sd->menuskill_val = skill_lv;
 }
 
 
@@ -15097,7 +15098,7 @@ void clif_parse_BattleChat(int fd, struct map_session_data* sd)
 
 /// Notifies client of a battleground score change (ZC_BATTLEFIELD_NOTIFY_POINT).
 /// 02de <camp A points>.W <camp B points>.W
-void clif_bg_updatescore(int m)
+void clif_bg_updatescore(int16 m)
 {
 	struct block_list bl;
 	unsigned char buf[6];
@@ -16058,7 +16059,7 @@ int clif_spellbook_list(struct map_session_data *sd)
 /*==========================================
  * Magic Decoy Material List
  *------------------------------------------*/
-int clif_magicdecoy_list(struct map_session_data *sd, int skill_lv, short x, short y) {
+int clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short x, short y) {
 	int i, c;
 	int fd;
 
@@ -16094,7 +16095,7 @@ int clif_magicdecoy_list(struct map_session_data *sd, int skill_lv, short x, sho
 /*==========================================
  * Guillotine Cross Poisons List
  *------------------------------------------*/
-int clif_poison_list(struct map_session_data *sd, int skill_lv) {
+int clif_poison_list(struct map_session_data *sd, uint16 skill_lv) {
 	int i, c;
 	int fd;
 
@@ -16158,7 +16159,7 @@ int clif_autoshadowspell_list(struct map_session_data *sd) {
  * Skill list for Four Elemental Analysis
  * and Change Material skills.
  *------------------------------------------*/
-int clif_skill_itemlistwindow( struct map_session_data *sd, int skill_id, int skill_lv )
+int clif_skill_itemlistwindow( struct map_session_data *sd, uint16 skill_id, uint16 skill_lv )
 {
 #if PACKETVER >= 20090922
 	int fd;
@@ -16247,7 +16248,7 @@ void clif_parse_SkillSelectMenu(int fd, struct map_session_data *sd) {
 		return;
 
 	if( pc_istrading(sd) ) {
-		clif_skill_fail(sd,sd->ud.skillid,0,0);
+		clif_skill_fail(sd,sd->ud.skill_id,0,0);
 		clif_menuskill_clear(sd);
 		return;
 	}

src/map/clif.h

@@ -425,25 +425,25 @@ void clif_class_change(struct block_list *bl,int class_,int type);
 #define clif_mob_class_change(md, class_) clif_class_change(&md->bl, class_, 1)
 
 void clif_skillinfoblock(struct map_session_data *sd);
-void clif_skillup(struct map_session_data *sd,int skill_num);
+void clif_skillup(struct map_session_data *sd,uint16 skill_id);
 void clif_skillinfo(struct map_session_data *sd,int skill, int inf);
 void clif_addskill(struct map_session_data *sd, int id);
 void clif_deleteskill(struct map_session_data *sd, int id);
 
-void clif_skillcasting(struct block_list* bl, int src_id, int dst_id, int dst_x, int dst_y, int skill_num, int property, int casttime);
+void 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);
 void clif_skillcastcancel(struct block_list* bl);
-void clif_skill_fail(struct map_session_data *sd,int skill_id,enum useskill_fail_cause cause,int btype);
-void clif_skill_cooldown(struct map_session_data *sd, int skillid, unsigned int tick);
-int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,int skill_id,int skill_lv,int type);
-//int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,int skill_id,int skill_lv,int type);
-int clif_skill_nodamage(struct block_list *src,struct block_list *dst,int skill_id,int heal,int fail);
-void clif_skill_poseffect(struct block_list *src,int skill_id,int val,int x,int y,int tick);
+void clif_skill_fail(struct map_session_data *sd,uint16 skill_id,enum useskill_fail_cause cause,int btype);
+void clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int tick);
+int clif_skill_damage(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type);
+//int clif_skill_damage2(struct block_list *src,struct block_list *dst,unsigned int tick,int sdelay,int ddelay,int damage,int div,uint16 skill_id,uint16 skill_lv,int type);
+int clif_skill_nodamage(struct block_list *src,struct block_list *dst,uint16 skill_id,int heal,int fail);
+void clif_skill_poseffect(struct block_list *src,uint16 skill_id,int val,int x,int y,int tick);
 void clif_skill_estimation(struct map_session_data *sd,struct block_list *dst);
-void clif_skill_warppoint(struct map_session_data* sd, short skill_num, short skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4);
+void 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);
 void clif_skill_memomessage(struct map_session_data* sd, int type);
 void clif_skill_teleportmessage(struct map_session_data *sd, int type);
-void clif_skill_produce_mix_list(struct map_session_data *sd, int skillid, int trigger);
-void clif_cooking_list(struct map_session_data *sd, int trigger, int skill_id, int qty, int list_type);
+void clif_skill_produce_mix_list(struct map_session_data *sd, uint16 skill_id, int trigger);
+void clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type);
 
 void clif_produceeffect(struct map_session_data* sd,int flag,int nameid);
 
@@ -452,12 +452,12 @@ void clif_skill_delunit(struct skill_unit *unit);
 
 void clif_skillunit_update(struct block_list* bl);
 
-void clif_autospell(struct map_session_data *sd,int skilllv);
+void clif_autospell(struct map_session_data *sd,uint16 skill_lv);
 void clif_devotion(struct block_list *src, struct map_session_data *tsd);
 void clif_spiritball(struct block_list *bl);
 void clif_combo_delay(struct block_list *bl,int wait);
 void clif_bladestop(struct block_list *src, int dst_id, int active);
-void clif_changemapcell(int fd, int m, int x, int y, int type, enum send_target target);
+void clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_target target);
 
 #define clif_status_load(bl, type, flag) clif_status_change((bl), (type), (flag), 0, 0, 0, 0)
 void clif_status_change(struct block_list *bl,int type,int flag,int tick,int val1, int val2, int val3);
@@ -487,7 +487,7 @@ void clif_item_repaireffect(struct map_session_data *sd, int idx, int flag);
 void clif_item_damaged(struct map_session_data* sd, unsigned short position);
 void clif_item_refine_list(struct map_session_data *sd);
 
-void clif_item_skill(struct map_session_data *sd,int skillid,int skilllv);
+void clif_item_skill(struct map_session_data *sd,uint16 skill_id,uint16 skill_lv);
 
 void clif_mvp_effect(struct map_session_data *sd);
 void clif_mvp_item(struct map_session_data *sd,int nameid);
@@ -540,7 +540,7 @@ void clif_guild_emblem(struct map_session_data *sd,struct guild *g);
 void clif_guild_emblem_area(struct block_list* bl);
 void clif_guild_notice(struct map_session_data* sd, struct guild* g);
 void clif_guild_message(struct guild *g,int account_id,const char *mes,int len);
-int clif_guild_skillup(struct map_session_data *sd,int skill_num,int lv);
+int clif_guild_skillup(struct map_session_data *sd,uint16 skill_id,int lv);
 void clif_guild_reqalliance(struct map_session_data *sd,int account_id,const char *name);
 void clif_guild_allianceack(struct map_session_data *sd,int flag);
 void clif_guild_delalliance(struct map_session_data *sd,int guild_id,int flag);
@@ -555,7 +555,7 @@ void clif_bg_hp(struct map_session_data *sd);
 void clif_bg_xy(struct map_session_data *sd);
 void clif_bg_xy_remove(struct map_session_data *sd);
 void clif_bg_message(struct battleground_data *bg, int src_id, const char *name, const char *mes, int len);
-void clif_bg_updatescore(int m);
+void clif_bg_updatescore(int16 m);
 void clif_bg_updatescore_single(struct map_session_data *sd);
 void clif_sendbgemblem_area(struct map_session_data *sd);
 void clif_sendbgemblem_single(int fd, struct map_session_data *sd);
@@ -600,7 +600,7 @@ int clif_friendslist_toggle_sub(struct map_session_data *sd,va_list ap);
 void clif_friendslist_send(struct map_session_data *sd);
 void clif_friendslist_reqack(struct map_session_data *sd, struct map_session_data *f_sd, int type);
 
-void clif_weather(int m); // [Valaris]
+void clif_weather(int16 m); // [Valaris]
 void clif_specialeffect(struct block_list* bl, int type, enum send_target target); // special effects [Valaris]
 void clif_specialeffect_single(struct block_list* bl, int type, int fd);
 void clif_messagecolor(struct block_list* bl, unsigned long color, const char* msg); // Mob/Npc color talk [SnakeDrak]
@@ -618,7 +618,7 @@ void clif_get_weapon_view(struct map_session_data* sd, unsigned short *rhand, un
 
 void clif_party_xy_remove(struct map_session_data *sd); //Fix for minimap [Kevin]
 void clif_gospel_info(struct map_session_data *sd, int type);
-void clif_feel_req(int fd, struct map_session_data *sd, int skilllv);
+void clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv);
 void clif_starskill(struct map_session_data* sd, const char* mapname, int monster_id, unsigned char star, unsigned char result);
 void clif_feel_info(struct map_session_data* sd, unsigned char feel_level, unsigned char type);
 void clif_hate_info(struct map_session_data *sd, unsigned char hate_level,int class_, unsigned char type);
@@ -628,7 +628,7 @@ void clif_feel_hate_reset(struct map_session_data *sd);
 // [blackhole89]
 void clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int flag);
 int clif_homskillinfoblock(struct map_session_data *sd);
-void clif_homskillup(struct map_session_data *sd, int skill_num);	//[orn]
+void clif_homskillup(struct map_session_data *sd, uint16 skill_id);	//[orn]
 int clif_hom_food(struct map_session_data *sd,int foodid,int fail);	//[orn]
 void clif_send_homdata(struct map_session_data *sd, int state, int param);	//[orn]
 
@@ -639,7 +639,7 @@ void clif_equipcheckbox(struct map_session_data* sd);
 
 void clif_msg(struct map_session_data* sd, unsigned short id);
 void clif_msg_value(struct map_session_data* sd, unsigned short id, int value);
-void clif_msg_skill(struct map_session_data* sd, unsigned short skill_id, int msg_id);
+void clif_msg_skill(struct map_session_data* sd, uint16 skill_id, int msg_id);
 
 //quest system [Kevin] [Inkfish]
 void clif_quest_send_list(struct map_session_data * sd);
@@ -737,9 +737,9 @@ void clif_millenniumshield(struct map_session_data *sd, short shields );
 
 int clif_spellbook_list(struct map_session_data *sd);
 
-int clif_magicdecoy_list(struct map_session_data *sd, int skill_lv, short x, short y);
+int clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short x, short y);
 
-int clif_poison_list(struct map_session_data *sd, int skill_lv);
+int clif_poison_list(struct map_session_data *sd, uint16 skill_lv);
 
 int clif_autoshadowspell_list(struct map_session_data *sd);
 
@@ -747,7 +747,7 @@ int clif_status_load_notick(struct block_list *bl,int type,int flag,int val1, in
 int clif_status_load_single(int fd, int id,int type,int flag,int val1, int val2, int val3);
 
 
-int clif_skill_itemlistwindow( struct map_session_data *sd, int skill_id, int skill_lv );
+int clif_skill_itemlistwindow( struct map_session_data *sd, uint16 skill_id, uint16 skill_lv );
 void clif_elemental_info(struct map_session_data *sd);
 void clif_elemental_updatestatus(struct map_session_data *sd, int type);
 

src/map/elemental.c

@@ -53,7 +53,7 @@ struct view_data * elemental_get_viewdata(int class_) {
 	int i = elemental_search_index(class_);
 	if( i < 0 )
 		return 0;
-	
+
 	return &elemental_db[i].vd;
 }
 
@@ -61,15 +61,15 @@ int elemental_create(struct map_session_data *sd, int class_, unsigned int lifet
 	struct s_elemental ele;
 	struct s_elemental_db *db;
 	int i;
-	
+
 	nullpo_retr(1,sd);
-	
+
 	if( (i = elemental_search_index(class_)) < 0 )
 		return 0;
-	
+
 	db = &elemental_db[i];
 	memset(&ele,0,sizeof(struct s_elemental));
-	
+
 	ele.char_id = sd->status.char_id;
 	ele.class_ = class_;
 	ele.mode = EL_MODE_PASSIVE; // Initial mode
@@ -97,7 +97,7 @@ int elemental_create(struct map_session_data *sd, int class_, unsigned int lifet
 	ele.flee = sd->status.base_level / (5-i);
 	//Caster’s HIT + (Caster’s Base Level )
 	ele.hit = sd->battle_status.hit + sd->status.base_level;
-	
+
 	//per individual bonuses
 	switch(db->class_){
 	case 2114:	case 2115:
@@ -133,10 +133,10 @@ int elemental_create(struct map_session_data *sd, int class_, unsigned int lifet
 	}
 
 	ele.life_time = lifetime;
-	
+
 	// Request Char Server to create this elemental
 	intif_elemental_create(&ele);
-	
+
 	return 1;
 }
 
@@ -144,7 +144,7 @@ int elemental_get_lifetime(struct elemental_data *ed) {
 	const struct TimerData * td;
 	if( ed == NULL || ed->summon_timer == INVALID_TIMER )
 		return 0;
-	
+
 	td = get_timer(ed->summon_timer);
 	return (td != NULL) ? DIFF_TICK(td->tick, gettick()) : 0;
 }
@@ -170,20 +170,20 @@ int elemental_save(struct elemental_data *ed) {
 static int elemental_summon_end(int tid, unsigned int tick, int id, intptr_t data) {
 	struct map_session_data *sd;
 	struct elemental_data *ed;
-	
+
 	if( (sd = map_id2sd(id)) == NULL )
 		return 1;
 	if( (ed = sd->ed) == NULL )
 		return 1;
-	
+
 	if( ed->summon_timer != tid ) {
 		ShowError("elemental_summon_end %d != %d.\n", ed->summon_timer, tid);
 		return 0;
 	}
-	
+
 	ed->summon_timer = INVALID_TIMER;
 	elemental_delete(ed, 0); // Elemental's summon time is over.
-	
+
 	return 0;
 }
 
@@ -196,28 +196,28 @@ void elemental_summon_stop(struct elemental_data *ed) {
 
 int elemental_delete(struct elemental_data *ed, int reply) {
 	struct map_session_data *sd;
-	
+
 	nullpo_ret(ed);
-	
+
 	sd = ed->master;
 	ed->elemental.life_time = 0;
-	
+
 	elemental_clean_effect(ed);
 	elemental_summon_stop(ed);
-	
+
 	if( !sd )
 		return unit_free(&ed->bl, 0);
-	
+
 	sd->ed = NULL;
 	sd->status.ele_id = 0;
-	
+
 	return unit_remove_map(&ed->bl, 0);
 }
 
 void elemental_summon_init(struct elemental_data *ed) {
 	if( ed->summon_timer == INVALID_TIMER )
 		ed->summon_timer = add_timer(gettick() + ed->elemental.life_time, elemental_summon_end, ed->master->bl.id, 0);
-	
+
 	ed->regen.state.block = 0;
 }
 
@@ -226,15 +226,15 @@ int elemental_data_received(struct s_elemental *ele, bool flag) {
 	struct elemental_data *ed;
 	struct s_elemental_db *db;
 	int i = elemental_search_index(ele->class_);
-	
+
 	if( (sd = map_charid2sd(ele->char_id)) == NULL )
 		return 0;
-	
+
 	if( !flag || i < 0 ) { // Not created - loaded - DB info
 		sd->status.ele_id = 0;
 		return 0;
 	}
-	
+
 	db = &elemental_db[i];
 	if( !sd->ed ) {	// Initialize it after first summon.
 		sd->ed = ed = (struct elemental_data*)aCalloc(1,sizeof(struct elemental_data));
@@ -248,14 +248,14 @@ int elemental_data_received(struct s_elemental *ele, bool flag) {
 		status_change_init(&ed->bl);
 		unit_dataset(&ed->bl);
 		ed->ud.dir = sd->ud.dir;
-		
+
 		ed->bl.m = sd->bl.m;
 		ed->bl.x = sd->bl.x;
 		ed->bl.y = sd->bl.y;
 		unit_calc_pos(&ed->bl, sd->bl.x, sd->bl.y, sd->ud.dir);
 		ed->bl.x = ed->ud.to_x;
 		ed->bl.y = ed->ud.to_y;
-		
+
 		map_addiddb(&ed->bl);
 		status_calc_elemental(ed,1);
 		ed->last_spdrain_time = ed->last_thinktime = gettick();
@@ -265,9 +265,9 @@ int elemental_data_received(struct s_elemental *ele, bool flag) {
 		memcpy(&sd->ed->elemental, ele, sizeof(struct s_elemental));
 		ed = sd->ed;
 	}
-	
+
 	sd->status.ele_id = ele->elemental_id;
-	
+
 	if( ed->bl.prev == NULL && sd->bl.prev != NULL ) {
 		map_addblock(&ed->bl);
 		clif_spawn(&ed->bl);
@@ -276,18 +276,18 @@ int elemental_data_received(struct s_elemental *ele, bool flag) {
 		clif_hpmeter_single(sd->fd,ed->bl.id,ed->battle_status.hp,ed->battle_status.max_hp);
 		clif_elemental_updatestatus(sd,SP_SP);
 	}
-	
+
 	return 1;
 }
 
-int elemental_clean_single_effect(struct elemental_data *ed, int skill_num) {
+int elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id) {
 	struct block_list *bl;
-	sc_type type = status_skill2sc(skill_num);
-	
+	sc_type type = status_skill2sc(skill_id);
+
 	nullpo_ret(ed);
-	
+
 	bl = battle_get_master(&ed->bl);
-	
+
 	if( type ) {
 		switch( type ) {
 				// Just remove status change.
@@ -323,15 +323,15 @@ int elemental_clean_single_effect(struct elemental_data *ed, int skill_num) {
 				break;
 		}
 	}
-	
+
 	return 1;
 }
 
 int elemental_clean_effect(struct elemental_data *ed) {
 	struct map_session_data *sd;
-	
+
 	nullpo_ret(ed);
-	
+
 	// Elemental side
 	status_change_end(&ed->bl, SC_TROPIC, INVALID_TIMER);
 	status_change_end(&ed->bl, SC_HEATER, INVALID_TIMER);
@@ -354,10 +354,10 @@ int elemental_clean_effect(struct elemental_data *ed) {
 	status_change_end(&ed->bl, SC_UPHEAVAL, INVALID_TIMER);
 	status_change_end(&ed->bl, SC_CIRCLE_OF_FIRE, INVALID_TIMER);
 	status_change_end(&ed->bl, SC_TIDAL_WEAPON, INVALID_TIMER);
-		
+
 	if( (sd = ed->master) == NULL )
 		return 0;
-	
+
 	// Master side
 	status_change_end(&sd->bl, SC_TROPIC_OPTION, INVALID_TIMER);
 	status_change_end(&sd->bl, SC_HEATER_OPTION, INVALID_TIMER);
@@ -383,68 +383,68 @@ int elemental_clean_effect(struct elemental_data *ed) {
 	status_change_end(&sd->bl, SC_UPHEAVAL_OPTION, INVALID_TIMER);
 	status_change_end(&sd->bl, SC_CIRCLE_OF_FIRE_OPTION, INVALID_TIMER);
 	status_change_end(&sd->bl, SC_TIDAL_WEAPON_OPTION, INVALID_TIMER);
-	
+
 	return 1;
 }
 
 int elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned int tick) {
 	struct skill_condition req;
-	short skillnum, skilllv;
+	uint16 skill_id, skill_lv;
 	int i;
-	
+
 	nullpo_ret(ed);
 	nullpo_ret(bl);
-	
+
 	if( !ed->master )
 		return 0;
-	
+
 	if( ed->target_id )
 		elemental_unlocktarget(ed);	// Remove previous target.
-	
+
 	ARR_FIND(0, MAX_ELESKILLTREE, i, ed->db->skill[i].id && (ed->db->skill[i].mode&EL_SKILLMODE_AGGRESSIVE));
 	if( i == MAX_ELESKILLTREE )
 		return 0;
-	
-	skillnum = ed->db->skill[i].id;
-	skilllv = ed->db->skill[i].lv;
-	
-	if( elemental_skillnotok(skillnum, ed) )
+
+	skill_id = ed->db->skill[i].id;
+	skill_lv = ed->db->skill[i].lv;
+
+	if( elemental_skillnotok(skill_id, ed) )
 		return 0;
-	
+
 	if( ed->ud.skilltimer != INVALID_TIMER )
 		return 0;
 	else if( DIFF_TICK(tick, ed->ud.canact_tick) < 0 )
 		return 0;
-	
+
 	ed->target_id = ed->ud.skilltarget = bl->id;	// Set new target
 	ed->last_thinktime = tick;
-	
+
 	// Not in skill range.
-	if( !battle_check_range(&ed->bl,bl,skill_get_range(skillnum,skilllv)) ) {
+	if( !battle_check_range(&ed->bl,bl,skill_get_range(skill_id,skill_lv)) ) {
 		// Try to walk to the target.
-		if( !unit_walktobl(&ed->bl, bl, skill_get_range(skillnum,skilllv), 2) )
+		if( !unit_walktobl(&ed->bl, bl, skill_get_range(skill_id,skill_lv), 2) )
 			elemental_unlocktarget(ed);
 		else {
 			// Walking, waiting to be in range. Client don't handle it, then we must handle it here.
-			int walk_dist = distance_bl(&ed->bl,bl) - skill_get_range(skillnum,skilllv);
-			ed->ud.skillid = skillnum;
-			ed->ud.skilllv = skilllv;
-			
-			if( skill_get_inf(skillnum) & INF_GROUND_SKILL )
+			int walk_dist = distance_bl(&ed->bl,bl) - skill_get_range(skill_id,skill_lv);
+			ed->ud.skill_id = skill_id;
+			ed->ud.skill_lv = skill_lv;
+
+			if( skill_get_inf(skill_id) & INF_GROUND_SKILL )
 				ed->ud.skilltimer = add_timer( tick+status_get_speed(&ed->bl)*walk_dist, skill_castend_pos, ed->bl.id, 0 );
 			else
 				ed->ud.skilltimer = add_timer( tick+status_get_speed(&ed->bl)*walk_dist, skill_castend_id, ed->bl.id, 0 );
 		}
 		return 1;
-		
+
 	}
 
-	req = elemental_skill_get_requirements(skillnum, skilllv);
+	req = elemental_skill_get_requirements(skill_id, skill_lv);
 
 	if(req.hp || req.sp){
 		struct map_session_data *sd = BL_CAST(BL_PC, battle_get_master(&ed->bl));
 		if( sd ){
-			if( sd->skillid_old != SO_EL_ACTION && //regardless of remaining HP/SP it can be cast
+			if( sd->skill_id_old != SO_EL_ACTION && //regardless of remaining HP/SP it can be cast
 				(status_get_hp(&ed->bl) < req.hp || status_get_sp(&ed->bl) < req.sp) )
 				return 1;
 			else
@@ -453,14 +453,14 @@ int elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned
 	}
 
 	//Otherwise, just cast the skill.
-	if( skill_get_inf(skillnum) & INF_GROUND_SKILL )
-		unit_skilluse_pos(&ed->bl, bl->x, bl->y, skillnum, skilllv);
+	if( skill_get_inf(skill_id) & INF_GROUND_SKILL )
+		unit_skilluse_pos(&ed->bl, bl->x, bl->y, skill_id, skill_lv);
 	else
-		unit_skilluse_id(&ed->bl, bl->id, skillnum, skilllv);
-	
+		unit_skilluse_id(&ed->bl, bl->id, skill_id, skill_lv);
+
 	// Reset target.
 	ed->target_id = 0;
-	
+
 	return 1;
 }
 
@@ -470,40 +470,40 @@ int elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned
  *-------------------------------------------------------------*/
 int elemental_change_mode_ack(struct elemental_data *ed, int mode) {
 	struct block_list *bl = &ed->master->bl;
-	short skillnum, skilllv;
+	uint16 skill_id, skill_lv;
 	int i;
-	
+
 	nullpo_ret(ed);
-	
+
 	if( !bl )
 		return 0;
-	
+
 	// Select a skill.
 	ARR_FIND(0, MAX_ELESKILLTREE, i, ed->db->skill[i].id && (ed->db->skill[i].mode&mode));
 	if( i == MAX_ELESKILLTREE )
 		return 0;
-	
-	skillnum = ed->db->skill[i].id;
-	skilllv = ed->db->skill[i].lv;
-	
-	if( elemental_skillnotok(skillnum, ed) )
+
+	skill_id = ed->db->skill[i].id;
+	skill_lv = ed->db->skill[i].lv;
+
+	if( elemental_skillnotok(skill_id, ed) )
 		return 0;
-	
+
 	if( ed->ud.skilltimer != INVALID_TIMER )
 		return 0;
 	else if( DIFF_TICK(gettick(), ed->ud.canact_tick) < 0 )
 		return 0;
-	
+
 	ed->target_id = bl->id;	// Set new target
 	ed->last_thinktime = gettick();
-	
-	if( skill_get_inf(skillnum) & INF_GROUND_SKILL )
-		unit_skilluse_pos(&ed->bl, bl->x, bl->y, skillnum, skilllv);
+
+	if( skill_get_inf(skill_id) & INF_GROUND_SKILL )
+		unit_skilluse_pos(&ed->bl, bl->x, bl->y, skill_id, skill_lv);
 	else
-		unit_skilluse_id(&ed->bl,bl->id,skillnum,skilllv);
-	
+		unit_skilluse_id(&ed->bl,bl->id,skill_id,skill_lv);
+
 	ed->target_id = 0;	// Reset target after casting the skill  to avoid continious attack.
-	
+
 	return 1;
 }
 
@@ -512,20 +512,20 @@ int elemental_change_mode_ack(struct elemental_data *ed, int mode) {
  *-------------------------------------------------------------*/
 int elemental_change_mode(struct elemental_data *ed, int mode) {
 	nullpo_ret(ed);
-	
+
 	// Remove target
 	elemental_unlocktarget(ed);
-	
+
 	// Removes the effects of the previous mode.
 	if(ed->elemental.mode != mode ) elemental_clean_effect(ed);
-	
+
 	ed->battle_status.mode = ed->elemental.mode = mode;
-	
+
 	// Normalize elemental mode to elemental skill mode.
 	if( mode == EL_MODE_AGGRESSIVE ) mode = EL_SKILLMODE_AGGRESSIVE;	// Aggressive spirit mode -> Aggressive spirit skill.
 	else if( mode == EL_MODE_ASSIST ) mode = EL_SKILLMODE_ASSIST;		// Assist spirit mode -> Assist spirit skill.
 	else mode = EL_SKILLMODE_PASIVE;									// Passive spirit mode -> Passive spirit skill.
-	
+
 	// Use a skill inmediately after every change mode.
 	if( mode != EL_SKILLMODE_AGGRESSIVE )
 		elemental_change_mode_ack(ed,mode);
@@ -546,56 +546,56 @@ int elemental_dead(struct elemental_data *ed) {
 
 int elemental_unlocktarget(struct elemental_data *ed) {
 	nullpo_ret(ed);
-	
+
 	ed->target_id = 0;
 	elemental_stop_attack(ed);
 	elemental_stop_walking(ed,1);
 	return 0;
 }
 
-int elemental_skillnotok(int skillid, struct elemental_data *ed) {
-	int i = skill_get_index(skillid);
+int elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) {
+	int idx = skill_get_index(skill_id);
 	nullpo_retr(1,ed);
-	
-	if (i == 0)
+
+	if (idx == 0)
 		return 1; // invalid skill id
-		
-	return skillnotok(skillid, ed->master);
+
+	return skillnotok(skill_id, ed->master);
 }
 
-struct skill_condition elemental_skill_get_requirements(int skill, int lv){
+struct skill_condition elemental_skill_get_requirements(uint16 skill_id, uint16 skill_lv){
 	struct skill_condition req;
-	int id = skill_get_index(skill);
+	int idx = skill_get_index(skill_id);
 
 	memset(&req,0,sizeof(req));
 
-	if( id == 0 ) // invalid skill id
+	if( idx == 0 ) // invalid skill id
   		return req;
 
-	if( lv < 1 || lv > MAX_SKILL_LEVEL )
+	if( skill_lv < 1 || skill_lv > MAX_SKILL_LEVEL )
 		return req;
 
-	req.hp = skill_db[id].hp[lv-1];
-	req.sp = skill_db[id].sp[lv-1];
+	req.hp = skill_db[idx].hp[skill_lv-1];
+	req.sp = skill_db[idx].sp[skill_lv-1];
 
 	return req;
 }
 
 int elemental_set_target( struct map_session_data *sd, struct block_list *bl ) {
 	struct elemental_data *ed = sd->ed;
-	
+
 	nullpo_ret(ed);
 	nullpo_ret(bl);
-	
+
 	if( ed->bl.m != bl->m || !check_distance_bl(&ed->bl, bl, ed->db->range2) )
 		return 0;
-	
+
 	if( !status_check_skilluse(&ed->bl, bl, 0, 0) )
 		return 0;
-	
+
 	if( ed->target_id == 0 )
 		ed->target_id = bl->id;
-	
+
 	return 1;
 }
 
@@ -603,19 +603,19 @@ static int elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap
 	struct elemental_data *ed;
 	struct block_list **target;
 	int dist;
-	
+
 	nullpo_ret(bl);
-	
+
 	ed = va_arg(ap,struct elemental_data *);
 	target = va_arg(ap,struct block_list**);
-	
+
 	//If can't seek yet, not an enemy, or you can't attack it, skip.
 	if( (*target) == bl || !status_check_skilluse(&ed->bl, bl, 0, 0) )
 		return 0;
-	
+
 	if( battle_check_target(&ed->bl,bl,BCT_ENEMY) <= 0 )
 		return 0;
-	
+
 	switch( bl->type ) {
 		case BL_PC:
 			if( !map_flag_vs(ed->bl.m) )
@@ -638,10 +638,10 @@ static int elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap
 static int elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data *sd, unsigned int tick) {
 	struct block_list *target = NULL;
 	int master_dist, view_range, mode;
-	
+
 	nullpo_ret(ed);
 	nullpo_ret(sd);
-	
+
 	if( ed->bl.prev == NULL || sd == NULL || sd->bl.prev == NULL )
 		return 0;
 
@@ -660,7 +660,7 @@ static int elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_
 				break;
 		}
 
-		if( status_get_sp(&sd->bl) < sp ){ // Can't sustain delete it. 
+		if( status_get_sp(&sd->bl) < sp ){ // Can't sustain delete it.
 			elemental_delete(sd->ed,0);
 			return 0;
 		}
@@ -668,28 +668,28 @@ static int elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_
 		status_zap(&sd->bl,0,sp);
 		ed->last_spdrain_time = tick;
 	}
-	
+
 	if( DIFF_TICK(tick,ed->last_thinktime) < MIN_ELETHINKTIME )
 		return 0;
-	
+
 	ed->last_thinktime = tick;
-	
+
 	if( ed->ud.skilltimer != INVALID_TIMER )
 		return 0;
-	
+
 	if( ed->ud.walktimer != INVALID_TIMER && ed->ud.walkpath.path_pos <= 2 )
 		return 0; //No thinking when you just started to walk.
-	
+
 	if(ed->ud.walkpath.path_pos < ed->ud.walkpath.path_len && ed->ud.target == sd->bl.id)
 		return 0; //No thinking until be near the master.
-	
+
 	if( ed->sc.count && ed->sc.data[SC_BLIND] )
 		view_range = 3;
 	else
 		view_range = ed->db->range2;
-	
+
 	mode = status_get_mode(&ed->bl);
-	
+
 	master_dist = distance_bl(&sd->bl, &ed->bl);
 	if( master_dist > AREA_SIZE ) {	// Master out of vision range.
 		elemental_unlocktarget(ed);
@@ -705,42 +705,42 @@ static int elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_
 			return 0; //Already walking to him
 		if( DIFF_TICK(tick, ed->ud.canmove_tick) < 0 )
 			return 0; //Can't move yet.
-		if( map_search_freecell(&ed->bl, sd->bl.m, &x, &y, MIN_ELEDISTANCE, MIN_ELEDISTANCE, 1) 
+		if( map_search_freecell(&ed->bl, sd->bl.m, &x, &y, MIN_ELEDISTANCE, MIN_ELEDISTANCE, 1)
 		   && unit_walktoxy(&ed->bl, x, y, 0) )
 			return 0;
 	}
-	
+
 	if( mode == EL_MODE_AGGRESSIVE ) {
 		target = map_id2bl(ed->ud.target);
-		
+
 		if( !target )
 			map_foreachinrange(elemental_ai_sub_timer_activesearch, &ed->bl, view_range, BL_CHAR, ed, &target, status_get_mode(&ed->bl));
-		
+
 		if( !target ) { //No targets available.
 			elemental_unlocktarget(ed);
 			return 1;
 		}
-		
+
 		if( battle_check_range(&ed->bl,target,view_range) && rnd()%100 < 2 ) { // 2% chance to cast attack skill.
 			if(	elemental_action(ed,target,tick) )
 				return 1;
 		}
-		
+
 		//Attempt to attack.
 		//At this point we know the target is attackable, we just gotta check if the range matches.
 		if( ed->ud.target == target->id && ed->ud.attacktimer != INVALID_TIMER ) //Already locked.
 			return 1;
-		
+
 		if( battle_check_range(&ed->bl, target, ed->base_status.rhw.range) ) {//Target within range, engage
 			unit_attack(&ed->bl,target->id,1);
 			return 1;
 		}
-		
+
 		//Follow up if possible.
 		if( !unit_walktobl(&ed->bl, target, ed->base_status.rhw.range, 2) )
 			elemental_unlocktarget(ed);
 	}
-	
+
 	return 0;
 }
 
@@ -748,7 +748,7 @@ static int elemental_ai_sub_foreachclient(struct map_session_data *sd, va_list a
 	unsigned int tick = va_arg(ap,unsigned int);
 	if(sd->status.ele_id && sd->ed)
 		elemental_ai_sub_timer(sd->ed,sd,tick);
-	
+
 	return 0;
 }
 
@@ -764,24 +764,24 @@ int read_elementaldb(void) {
 	int i, j = 0, k = 0, ele;
 	struct s_elemental_db *db;
 	struct status_data *status;
-	
+
 	sprintf(line, "%s/%s", db_path, "elemental_db.txt");
 	memset(elemental_db,0,sizeof(elemental_db));
-	
+
 	fp = fopen(line, "r");
 	if( !fp ) {
 		ShowError("read_elementaldb : can't read elemental_db.txt\n");
 		return -1;
 	}
-	
+
 	while( fgets(line, sizeof(line), fp) && j < MAX_ELEMENTAL_CLASS ) {
 		k++;
 		if( line[0] == '/' && line[1] == '/' )
 			continue;
-		
+
 		if( line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
 			continue;
-		
+
 		i = 0;
 		p = strtok(line, ",");
 		while( p != NULL && i < 26 ) {
@@ -792,16 +792,16 @@ int read_elementaldb(void) {
 			ShowError("read_elementaldb : Incorrect number of columns at elemental_db.txt line %d.\n", k);
 			continue;
 		}
-		
+
 		db = &elemental_db[j];
 		db->class_ = atoi(str[0]);
 		strncpy(db->sprite, str[1], NAME_LENGTH);
 		strncpy(db->name, str[2], NAME_LENGTH);
 		db->lv = atoi(str[3]);
-		
+
 		status = &db->status;
 		db->vd.class_ = db->class_;
-		
+
 		status->max_hp = atoi(str[4]);
 		status->max_sp = atoi(str[5]);
 		status->rhw.range = atoi(str[6]);
@@ -819,7 +819,7 @@ int read_elementaldb(void) {
 		db->range3 = atoi(str[18]);
 		status->size = atoi(str[19]);
 		status->race = atoi(str[20]);
-		
+
 		ele = atoi(str[21]);
 		status->def_ele = ele%10;
 		status->ele_lv = ele/20;
@@ -831,19 +831,19 @@ int read_elementaldb(void) {
 			ShowWarning("Elemental %d has invalid element level %d (max is 4)\n", db->class_, status->ele_lv);
 			status->ele_lv = 1;
 		}
-		
+
 		status->aspd_rate = 1000;
 		status->speed = atoi(str[22]);
 		status->adelay = atoi(str[23]);
 		status->amotion = atoi(str[24]);
 		status->dmotion = atoi(str[25]);
-		
+
 		j++;
 	}
-	
+
 	fclose(fp);
 	ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' elementals in '"CL_WHITE"db/elemental_db.txt"CL_RESET"'.\n",j);
-	
+
 	return 0;
 }
 
@@ -853,23 +853,23 @@ int read_elemental_skilldb(void) {
 	char *str[4];
 	struct s_elemental_db *db;
 	int i, j = 0, k = 0, class_;
-	int skillid, skilllv, skillmode;
-	
+	uint16 skill_id, skill_lv, skillmode;
+
 	sprintf(line, "%s/%s", db_path, "elemental_skill_db.txt");
 	fp = fopen(line, "r");
 	if( !fp ) {
 		ShowError("read_elemental_skilldb : can't read elemental_skill_db.txt\n");
 		return -1;
 	}
-	
+
 	while( fgets(line, sizeof(line), fp) ) {
 		k++;
 		if( line[0] == '/' && line[1] == '/' )
 			continue;
 
 		if( line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
-			continue; 
-		
+			continue;
+
 		i = 0;
 		p = strtok(line, ",");
 		while( p != NULL && i < 4 ) {
@@ -880,39 +880,39 @@ int read_elemental_skilldb(void) {
 			ShowError("read_elemental_skilldb : Incorrect number of columns at elemental_skill_db.txt line %d.\n", k);
 			continue;
 		}
-		
+
 		class_ = atoi(str[0]);
 		ARR_FIND(0, MAX_ELEMENTAL_CLASS, i, class_ == elemental_db[i].class_);
 		if( i == MAX_ELEMENTAL_CLASS ) {
 			ShowError("read_elemental_skilldb : Class not found in elemental_db for skill entry, line %d.\n", k);
 			continue;
 		}
-		
-		skillid = atoi(str[1]);
-		if( skillid < EL_SKILLBASE || skillid >= EL_SKILLBASE + MAX_ELEMENTALSKILL ) {
+
+		skill_id = atoi(str[1]);
+		if( skill_id < EL_SKILLBASE || skill_id >= EL_SKILLBASE + MAX_ELEMENTALSKILL ) {
 			ShowError("read_elemental_skilldb : Skill out of range, line %d.\n", k);
 			continue;
 		}
-		
+
 		db = &elemental_db[i];
-		skilllv = atoi(str[2]);
-		
+		skill_lv = atoi(str[2]);
+
 		skillmode = atoi(str[3]);
 		if( skillmode < EL_SKILLMODE_PASIVE || skillmode > EL_SKILLMODE_AGGRESSIVE ) {
 			ShowError("read_elemental_skilldb : Skillmode out of range, line %d.\n",k);
 			continue;
 		}
-		ARR_FIND( 0, MAX_ELESKILLTREE, i, db->skill[i].id == 0 || db->skill[i].id == skillid );
+		ARR_FIND( 0, MAX_ELESKILLTREE, i, db->skill[i].id == 0 || db->skill[i].id == skill_id );
 		if( i == MAX_ELESKILLTREE ) {
-			ShowWarning("Unable to load skill %d into Elemental %d's tree. Maximum number of skills per elemental has been reached.\n", skillid, class_);
+			ShowWarning("Unable to load skill %d into Elemental %d's tree. Maximum number of skills per elemental has been reached.\n", skill_id, class_);
 			continue;
 		}
-		db->skill[i].id = skillid;
-		db->skill[i].lv = skilllv;
+		db->skill[i].id = skill_id;
+		db->skill[i].lv = skill_lv;
 		db->skill[i].mode = skillmode;
 		j++;
 	}
-	
+
 	fclose(fp);
 	ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' entries in '"CL_WHITE"db/elemental_skill_db.txt"CL_RESET"'.\n",j);
 	return 0;
@@ -930,10 +930,10 @@ void reload_elemental_skilldb(void) {
 int do_init_elemental(void) {
 	read_elementaldb();
 	read_elemental_skilldb();
-	
+
 	add_timer_func_list(elemental_ai_timer,"elemental_ai_timer");
 	add_timer_interval(gettick()+MIN_ELETHINKTIME,elemental_ai_timer,0,0,MIN_ELETHINKTIME);
-	
+
 	return 0;
 }
 

src/map/elemental.h

@@ -43,14 +43,14 @@ struct elemental_data {
 	struct status_data base_status, battle_status;
 	struct status_change sc;
 	struct regen_data regen;
-	
+
 	struct s_elemental_db *db;
 	struct s_elemental elemental;
-	
+
 	struct map_session_data *master;
 	int summon_timer;
 	int skill_timer;
-	
+
 	unsigned last_thinktime, last_linktime, last_spdrain_time;
 	short min_chase;
 	int target_id, attacked_id;
@@ -75,12 +75,12 @@ void elemental_summon_stop(struct elemental_data *ed);
 int elemental_get_lifetime(struct elemental_data *ed);
 
 int elemental_unlocktarget(struct elemental_data *ed);
-int elemental_skillnotok(int skillid, struct elemental_data *ed);
+int elemental_skillnotok(uint16 skill_id, struct elemental_data *ed);
 int elemental_set_target( struct map_session_data *sd, struct block_list *bl );
-int elemental_clean_single_effect(struct elemental_data *ed, int skill_num);
+int elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id);
 int elemental_clean_effect(struct elemental_data *ed);
 int elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned int tick);
-struct skill_condition elemental_skill_get_requirements(int skill, int lv);
+struct skill_condition elemental_skill_get_requirements(uint16 skill_id, uint16 skill_lv);
 
 #define elemental_stop_walking(ed, type) unit_stop_walking(&(ed)->bl, type)
 #define elemental_stop_attack(ed) unit_stop_attack(&(ed)->bl)

src/map/guild.c

@@ -96,7 +96,7 @@ int guild_skill_get_max (int id)
 	return guild_skill_tree[id-GD_SKILLBASE].max;
 }
 
-// Retrive skilllv learned by guild
+// Retrive skill_lv learned by guild
 
 int guild_checkskill(struct guild *g, int id) {
     int idx = id - GD_SKILLBASE;
@@ -110,18 +110,18 @@ int guild_checkskill(struct guild *g, int id) {
  *------------------------------------------*/
 static bool guild_read_guildskill_tree_db(char* split[], int columns, int current)
 {// <skill id>,<max lv>,<req id1>,<req lv1>,<req id2>,<req lv2>,<req id3>,<req lv3>,<req id4>,<req lv4>,<req id5>,<req lv5>
-	int k, id, skillid;
+	int k, id, skill_id;
 
-	skillid = atoi(split[0]);
-	id = skillid - GD_SKILLBASE;
+	skill_id = atoi(split[0]);
+	id = skill_id - GD_SKILLBASE;
 
 	if( id < 0 || id >= MAX_GUILDSKILL )
 	{
-		ShowWarning("guild_read_guildskill_tree_db: Invalid skill id %d.\n", skillid);
+		ShowWarning("guild_read_guildskill_tree_db: Invalid skill id %d.\n", skill_id);
 		return false;
 	}
 
-	guild_skill_tree[id].id = skillid;
+	guild_skill_tree[id].id = skill_id;
 	guild_skill_tree[id].max = atoi(split[1]);
 
 	if( guild_skill_tree[id].id == GD_GLORYGUILD && battle_config.require_glory_guild && guild_skill_tree[id].max == 0 )
@@ -1238,13 +1238,13 @@ int guild_getexp(struct map_session_data *sd,int exp)
 }
 
 /*====================================================
- * Ask to increase guildskill skill_num
+ * Ask to increase guildskill skill_id
  *---------------------------------------------------*/
-int guild_skillup(TBL_PC* sd, int skill_num)
+int guild_skillup(TBL_PC* sd, uint16 skill_id)
 {
 	struct guild* g;
-	int idx = skill_num - GD_SKILLBASE;
-	int max = guild_skill_get_max(skill_num);
+	int idx = skill_id - GD_SKILLBASE;
+	int max = guild_skill_get_max(skill_id);
 
 	nullpo_ret(sd);
 
@@ -1256,15 +1256,15 @@ int guild_skillup(TBL_PC* sd, int skill_num)
 	if( g->skill_point > 0 &&
 			g->skill[idx].id != 0 &&
 			g->skill[idx].lv < max )
-		intif_guild_skillup(g->guild_id, skill_num, sd->status.account_id, max);
+		intif_guild_skillup(g->guild_id, skill_id, sd->status.account_id, max);
 
 	return 0;
 }
 
 /*====================================================
- * Notification of guildskill skill_num increase request
+ * Notification of guildskill skill_id increase request
  *---------------------------------------------------*/
-int guild_skillupack(int guild_id,int skill_num,int account_id)
+int guild_skillupack(int guild_id,uint16 skill_id,int account_id)
 {
 	struct map_session_data *sd=map_id2sd(account_id);
 	struct guild *g=guild_search(guild_id);
@@ -1272,15 +1272,15 @@ int guild_skillupack(int guild_id,int skill_num,int account_id)
 	if(g==NULL)
 		return 0;
 	if( sd != NULL ) {
-		clif_guild_skillup(sd,skill_num,g->skill[skill_num-GD_SKILLBASE].lv);
+		clif_guild_skillup(sd,skill_id,g->skill[skill_id-GD_SKILLBASE].lv);
 
 		/* Guild Aura handling */
-		switch( skill_num ) {
+		switch( skill_id ) {
 			case GD_LEADERSHIP:
 			case GD_GLORYWOUNDS:
 			case GD_SOULCOLD:
 			case GD_HAWKEYES:
-					guild_guildaura_refresh(sd,skill_num,g->skill[skill_num-GD_SKILLBASE].lv);
+					guild_guildaura_refresh(sd,skill_id,g->skill[skill_id-GD_SKILLBASE].lv);
 				break;
 		}
 	}
@@ -1293,9 +1293,9 @@ int guild_skillupack(int guild_id,int skill_num,int account_id)
 	return 0;
 }
 
-void guild_guildaura_refresh(struct map_session_data *sd, int skill_num, int skill_lv) {
+void guild_guildaura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
 	struct skill_unit_group* group = NULL;
-	int type = status_skill2sc(skill_num);
+	int type = status_skill2sc(skill_id);
 	if( !(battle_config.guild_aura&((agit_flag || agit2_flag)?2:1)) &&
 			!(battle_config.guild_aura&(map_flag_gvg2(sd->bl.m)?8:4)) )
 		return;
@@ -1305,7 +1305,7 @@ void guild_guildaura_refresh(struct map_session_data *sd, int skill_num, int ski
 		skill_delunitgroup(group);
 		status_change_end(&sd->bl,type,INVALID_TIMER);
 	}
-	group = skill_unitsetting(&sd->bl,skill_num,skill_lv,sd->bl.x,sd->bl.y,0);
+	group = skill_unitsetting(&sd->bl,skill_id,skill_lv,sd->bl.x,sd->bl.y,0);
 	if( group ) {
 		sc_start4(&sd->bl,type,100,(battle_config.guild_aura&16)?0:skill_lv,0,0,group->group_id,600000);//duration doesn't matter these status never end with val4
 	}
@@ -1335,10 +1335,10 @@ int guild_get_alliance_count(struct guild *g,int flag)
 // Blocks all guild skills which have a common delay time.
 void guild_block_skill(struct map_session_data *sd, int time)
 {
-	int skill_num[] = { GD_BATTLEORDER, GD_REGENERATION, GD_RESTORE, GD_EMERGENCYCALL };
+	uint16 skill_id[] = { GD_BATTLEORDER, GD_REGENERATION, GD_RESTORE, GD_EMERGENCYCALL };
 	int i;
 	for (i = 0; i < 4; i++)
-		skill_blockpc_start_(sd, skill_num[i], time , true);
+		skill_blockpc_start_(sd, skill_id[i], time , true);
 }
 
 /*====================================================

src/map/guild.h

@@ -60,7 +60,7 @@ int guild_member_withdraw(int guild_id,int account_id,int char_id,int flag,
 	const char *name,const char *mes);
 int guild_expulsion(struct map_session_data *sd,int guild_id,
 	int account_id,int char_id,const char *mes);
-int guild_skillup(struct map_session_data* sd, int skill_num);
+int guild_skillup(struct map_session_data* sd, uint16 skill_id);
 void guild_block_skill(struct map_session_data *sd, int time);
 int guild_reqalliance(struct map_session_data *sd,struct map_session_data *tsd);
 int guild_reply_reqalliance(struct map_session_data *sd,int account_id,int flag);
@@ -84,7 +84,7 @@ int guild_emblem_changed(int len,int guild_id,int emblem_id,const char *data);
 int guild_send_message(struct map_session_data *sd,const char *mes,int len);
 int guild_recv_message(int guild_id,int account_id,const char *mes,int len);
 int guild_send_dot_remove(struct map_session_data *sd);
-int guild_skillupack(int guild_id,int skill_num,int account_id);
+int guild_skillupack(int guild_id,uint16 skill_id,int account_id);
 int guild_break(struct map_session_data *sd,char *name);
 int guild_broken(int guild_id,int flag);
 int guild_gm_change(int guild_id, struct map_session_data *sd);
@@ -105,7 +105,7 @@ void guild_flag_add(struct npc_data *nd);
 void guild_flag_remove(struct npc_data *nd);
 void guild_flags_clear(void);
 
-void guild_guildaura_refresh(struct map_session_data *sd, int skill_num, int skill_lv);
+void guild_guildaura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
 
 void do_final_guild(void);
 

src/map/homunculus.c

@@ -250,7 +250,7 @@ int merc_hom_calc_skilltree(struct homun_data *hd, int flag_evolve)
 	return 0;
 }
 
-int merc_hom_checkskill(struct homun_data *hd,int skill_id)
+int merc_hom_checkskill(struct homun_data *hd,uint16 skill_id)
 {
 	int i = skill_id - HM_SKILLBASE;
 	if(!hd)
@@ -263,15 +263,15 @@ int merc_hom_checkskill(struct homun_data *hd,int skill_id)
 }
 
 int merc_skill_tree_get_max(int id, int b_class){
-	int i, skillid;
+	int i, skill_id;
 	b_class -= HM_CLASS_BASE;
-	for(i=0;(skillid=hskill_tree[b_class][i].id)>0;i++)
-		if (id == skillid)
+	for(i=0;(skill_id=hskill_tree[b_class][i].id)>0;i++)
+		if (id == skill_id)
 			return hskill_tree[b_class][i].max;
 	return skill_get_max(id);
 }
 
-void merc_hom_skillup(struct homun_data *hd,int skillnum)
+void merc_hom_skillup(struct homun_data *hd,uint16 skill_id)
 {
 	int i = 0 ;
 	nullpo_retv(hd);
@@ -279,18 +279,18 @@ void merc_hom_skillup(struct homun_data *hd,int skillnum)
 	if(hd->homunculus.vaporize)
 		return;
 
-	i = skillnum - HM_SKILLBASE;
+	i = skill_id - HM_SKILLBASE;
 	if(hd->homunculus.skillpts > 0 &&
 		hd->homunculus.hskill[i].id &&
 		hd->homunculus.hskill[i].flag == SKILL_FLAG_PERMANENT && //Don't allow raising while you have granted skills. [Skotlex]
-		hd->homunculus.hskill[i].lv < merc_skill_tree_get_max(skillnum, hd->homunculus.class_)
+		hd->homunculus.hskill[i].lv < merc_skill_tree_get_max(skill_id, hd->homunculus.class_)
 		)
 	{
 		hd->homunculus.hskill[i].lv++;
 		hd->homunculus.skillpts-- ;
 		status_calc_homunculus(hd,0);
 		if (hd->master) {
-			clif_homskillup(hd->master, skillnum);
+			clif_homskillup(hd->master, skill_id);
 			clif_hominfo(hd->master,hd,0);
 			clif_homskillinfoblock(hd->master);
 		}

src/map/homunculus.h

@@ -95,9 +95,9 @@ struct view_data* merc_get_hom_viewdata(int class_);
 int hom_class2mapid(int hom_class);
 void merc_damage(struct homun_data *hd);
 int merc_hom_dead(struct homun_data *hd);
-void merc_hom_skillup(struct homun_data *hd,int skillnum);
+void merc_hom_skillup(struct homun_data *hd,uint16 skill_id);
 int merc_hom_calc_skilltree(struct homun_data *hd, int flag_evolve);
-int merc_hom_checkskill(struct homun_data *hd,int skill_id);
+int merc_hom_checkskill(struct homun_data *hd,uint16 skill_id);
 int merc_hom_gainexp(struct homun_data *hd,int exp);
 int merc_hom_levelup(struct homun_data *hd);
 int merc_hom_evolution(struct homun_data *hd);

src/map/instance.c

@@ -98,12 +98,13 @@ int instance_create(int party_id, const char *name)
  *--------------------------------------*/
 int instance_add_map(const char *name, int instance_id, bool usebasename)
 {
-	int m = map_mapname2mapid(name), i, im = -1;
+	int16 m = map_mapname2mapid(name);
+	int i, im = -1;
 	size_t num_cell, size;
 
 	if( m < 0 )
 		return -1; // source map not found
-		
+
 	if( !instance_is_valid(instance_id) )
 	{
 		ShowError("instance_add_map: trying to attach '%s' map to non-existing instance %d.\n", name, instance_id);
@@ -171,7 +172,7 @@ int instance_add_map(const char *name, int instance_id, bool usebasename)
  * party_id : source party of this instance
  * type : result (0 = map id | 1 = instance id)
  *--------------------------------------*/
-int instance_map2imap(int m, int instance_id)
+int instance_map2imap(int16 m, int instance_id)
 {
  	int i;
 
@@ -179,7 +180,7 @@ int instance_map2imap(int m, int instance_id)
 	{
 		return -1;
 	}
-	
+
 	for( i = 0; i < instance[instance_id].num_map; i++ )
  	{
 		if( instance[instance_id].map[i] && map[instance[instance_id].map[i]].instance_src_map == m )
@@ -193,7 +194,7 @@ int instance_map2imap(int m, int instance_id)
  * instance_id : where to search
  * result : mapid of map "m" in this instance
  *--------------------------------------*/
-int instance_mapid2imapid(int m, int instance_id)
+int instance_mapid2imapid(int16 m, int instance_id)
 {
 	if( map[m].flag.src4instance == 0 )
 		return m; // not instances found for this map
@@ -216,7 +217,7 @@ int instance_mapid2imapid(int m, int instance_id)
 int instance_map_npcsub(struct block_list* bl, va_list args)
 {
 	struct npc_data* nd = (struct npc_data*)bl;
-	int m = va_arg(args, int); // Destination Map
+	int16 m = va_arg(args, int); // Destination Map
 
 	npc_duplicate4instance(nd, m);
 	return 1;
@@ -245,7 +246,7 @@ void instance_init(int instance_id)
  *--------------------------------------*/
 int instance_del_load(struct map_session_data* sd, va_list args)
 {
-	int m = va_arg(args,int);
+	int16 m = va_arg(args,int);
 	if( !sd || sd->bl.m != m )
 		return 0;
 
@@ -256,7 +257,7 @@ int instance_del_load(struct map_session_data* sd, va_list args)
 /* for npcs behave differently when being unloaded within a instance */
 int instance_cleanup_sub(struct block_list *bl, va_list ap) {
 	nullpo_ret(bl);
-	
+
 	switch(bl->type) {
 		case BL_PC:
 			map_quit((struct map_session_data *) bl);
@@ -277,14 +278,14 @@ int instance_cleanup_sub(struct block_list *bl, va_list ap) {
 			skill_delunit((struct skill_unit *) bl);
 			break;
 	}
-	
+
 	return 1;
 }
 
 /*--------------------------------------
  * Removes a simple instance map
  *--------------------------------------*/
-void instance_del_map(int m)
+void instance_del_map(int16 m)
 {
 	int i;
 	if( m <= 0 || !map[m].instance_id )
@@ -323,7 +324,7 @@ void instance_del_map(int m)
 
 	map_removemapdb(&map[m]);
 	memset(&map[m], 0x00, sizeof(map[0]));
-	
+
 	/* for it is default and makes it not try to delete a non-existent timer since we did not delete this entry. */
 	map[m].mob_delete_timer = INVALID_TIMER;
 }
@@ -421,7 +422,7 @@ void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsign
 
 	if( !instance_is_valid(instance_id) )
 		return;
-		
+
 	if( instance[instance_id].progress_timer != INVALID_TIMER )
 		delete_timer( instance[instance_id].progress_timer, instance_destroy_timer);
 	if( instance[instance_id].idle_timer != INVALID_TIMER )
@@ -437,7 +438,7 @@ void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsign
 		instance[instance_id].progress_timeout = 0;
 		instance[instance_id].progress_timer = INVALID_TIMER;
 	}
-		
+
 	if( idle_timeout )
 	{
 		instance[instance_id].idle_timeoutval = idle_timeout;
@@ -460,7 +461,7 @@ void instance_set_timeout(int instance_id, unsigned int progress_timeout, unsign
  *--------------------------------------*/
 void instance_check_kick(struct map_session_data *sd)
 {
-	int m = sd->bl.m;
+	int16 m = sd->bl.m;
 
 	clif_instance_leave(sd->fd);
 	if( map[m].instance_id )

src/map/instance.h

@@ -22,7 +22,7 @@ struct s_instance {
 	int users;
 
 	struct DBMap* vars; // Instance Variable for scripts
-	
+
 	int progress_timer;
 	time_t progress_timeout;
 
@@ -35,9 +35,9 @@ extern struct s_instance instance[MAX_INSTANCE];
 
 int instance_create(int party_id, const char *name);
 int instance_add_map(const char *name, int instance_id, bool usebasename);
-void instance_del_map(int m);
-int instance_map2imap(int m, int instance_id);
-int instance_mapid2imapid(int m, int instance_id);
+void instance_del_map(int16 m);
+int instance_map2imap(int16 m, int instance_id);
+int instance_mapid2imapid(int16 m, int instance_id);
 void instance_destroy(int instance_id);
 void instance_init(int instance_id);
 

src/map/intif.c

@@ -463,7 +463,7 @@ int intif_party_leave(int party_id,int account_id, int char_id)
 // Request keeping party for new map ??
 int intif_party_changemap(struct map_session_data *sd,int online)
 {
-	int m, mapindex;
+	int16 m, mapindex;
 
 	if (CheckForCharServer())
 		return 0;
@@ -702,15 +702,15 @@ int intif_guild_position(int guild_id,int idx,struct guild_position *p)
 	return 0;
 }
 
-// Request an update of Guildskill skillnum
-int intif_guild_skillup(int guild_id, int skill_num, int account_id, int max)
+// Request an update of Guildskill skill_id
+int intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int max)
 {
 	if( CheckForCharServer() )
 		return 0;
 	WFIFOHEAD(inter_fd, 18);
 	WFIFOW(inter_fd, 0)  = 0x303c;
 	WFIFOL(inter_fd, 2)  = guild_id;
-	WFIFOL(inter_fd, 6)  = skill_num;
+	WFIFOL(inter_fd, 6)  = skill_id;
 	WFIFOL(inter_fd, 10) = account_id;
 	WFIFOL(inter_fd, 14) = max;
 	WFIFOSET(inter_fd, 18);

src/map/intif.h

@@ -54,7 +54,7 @@ int intif_guild_change_gm(int guild_id, const char* name, int len);
 int intif_guild_change_basicinfo(int guild_id, int type, const void *data, int len);
 int intif_guild_change_memberinfo(int guild_id, int account_id, int char_id, int type, const void *data, int len);
 int intif_guild_position(int guild_id, int idx, struct guild_position *p);
-int intif_guild_skillup(int guild_id, int skill_num, int account_id, int max);
+int intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int max);
 int intif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int account_id2, int flag);
 int intif_guild_notice(int guild_id, const char *mes1, const char *mes2);
 int intif_guild_emblem(int guild_id, int len, const char *data);

src/map/itemdb.h

@@ -85,7 +85,7 @@ enum {
 #define UNKNOWN_ITEM_ID 512
 
 struct item_data {
-	int nameid;
+	uint16 nameid;
 	char name[ITEM_NAME_LENGTH],jname[ITEM_NAME_LENGTH];
 	
 	//Do not add stuff between value_buy and view_id (see how getiteminfo works)

src/map/log.c

@@ -172,7 +172,7 @@ void log_branch(struct map_session_data* sd)
 }
 
 /// logs item transactions (generic)
-void log_pick(int id, int m, e_log_pick_type type, int amount, struct item* itm)
+void log_pick(int id, int16 m, e_log_pick_type type, int amount, struct item* itm)
 {
 	nullpo_retv(itm);
 	if( ( log_config.enable_logs&type ) == 0 )
@@ -287,7 +287,7 @@ void log_mvpdrop(struct map_session_data* sd, int monster_id, int* log_mvp)
 		e_length = sprintf(entry,  LOG_QUERY " INTO `%s` (`mvp_date`, `kill_char_id`, `monster_id`, `prize`, `mvpexp`, `map`) VALUES (NOW(), '%d', '%d', '%d', '%d', '%s') ",
 						   log_config.log_mvpdrop, sd->status.char_id, monster_id, log_mvp[0], log_mvp[1], mapindex_id2name(sd->mapindex));
 		queryThread_log(entry,e_length);
-#else		
+#else
 		if( SQL_ERROR == Sql_Query(logmysql_handle, LOG_QUERY " INTO `%s` (`mvp_date`, `kill_char_id`, `monster_id`, `prize`, `mvpexp`, `map`) VALUES (NOW(), '%d', '%d', '%d', '%d', '%s') ",
 			log_config.log_mvpdrop, sd->status.char_id, monster_id, log_mvp[0], log_mvp[1], mapindex_id2name(sd->mapindex)) )
 		{
@@ -328,7 +328,7 @@ void log_atcommand(struct map_session_data* sd, const char* message)
 		int e_length = 0;
 		e_length = sprintf(entry,  LOG_QUERY " INTO `%s` (`atcommand_date`, `account_id`, `char_id`, `char_name`, `map`, `command`) VALUES (NOW(), '%d', '%d', '%s', '%s', '%s')", log_config.log_gm, sd->status.account_id, sd->status.char_id, sd->status.name ,mapindex_id2name(sd->mapindex), message);
 		queryThread_log(entry,e_length);
-#else				
+#else
 		SqlStmt* stmt;
 
 		stmt = SqlStmt_Malloc(logmysql_handle);
@@ -375,7 +375,7 @@ void log_npc(struct map_session_data* sd, const char* message)
 		int e_length = 0;
 		e_length = sprintf(entry, LOG_QUERY " INTO `%s` (`npc_date`, `account_id`, `char_id`, `char_name`, `map`, `mes`) VALUES (NOW(), '%d', '%d', '%s', '%s', '%s')", log_config.log_npc, sd->status.account_id, sd->status.char_id, sd->status.name, mapindex_id2name(sd->mapindex), message );
 		queryThread_log(entry,e_length);
-#else						
+#else
 		SqlStmt* stmt;
 		stmt = SqlStmt_Malloc(logmysql_handle);
 		if( SQL_SUCCESS != SqlStmt_Prepare(stmt, LOG_QUERY " INTO `%s` (`npc_date`, `account_id`, `char_id`, `char_name`, `map`, `mes`) VALUES (NOW(), '%d', '%d', ?, '%s', ?)", log_config.log_npc, sd->status.account_id, sd->status.char_id, mapindex_id2name(sd->mapindex) )
@@ -425,7 +425,7 @@ void log_chat(e_log_chat_type type, int type_id, int src_charid, int src_accid,
 		int e_length = 0;
 		e_length = sprintf(entry, LOG_QUERY " INTO `%s` (`time`, `type`, `type_id`, `src_charid`, `src_accountid`, `src_map`, `src_map_x`, `src_map_y`, `dst_charname`, `message`) VALUES (NOW(), '%c', '%d', '%d', '%d', '%s', '%d', '%d', '%s', '%s')", log_config.log_chat, log_chattype2char(type), type_id, src_charid, src_accid, map, x, y, dst_charname, message );
 		queryThread_log(entry,e_length);
-#else		
+#else
 		SqlStmt* stmt;
 
 		stmt = SqlStmt_Malloc(logmysql_handle);

src/map/map.c

@@ -277,7 +277,8 @@ static void map_delblcell(struct block_list *bl)
  *------------------------------------------*/
 int map_addblock(struct block_list* bl)
 {
-	int m, x, y, pos;
+	int16 m, x, y;
+	int pos;
 
 	nullpo_ret(bl);
 
@@ -475,7 +476,7 @@ int map_moveblock(struct block_list *bl, int x1, int y1, unsigned int tick)
 /*==========================================
  * Counts specified number of objects on given cell.
  *------------------------------------------*/
-int map_count_oncell(int m, int x, int y, int type)
+int map_count_oncell(int16 m, int16 x, int16 y, int type)
 {
 	int bx,by;
 	struct block_list *bl;
@@ -503,8 +504,8 @@ int map_count_oncell(int m, int x, int y, int type)
  * Looks for a skill unit on a given cell
  * flag&1: runs battle_check_target check based on unit->group->target_flag
  */
-struct skill_unit* map_find_skill_unit_oncell(struct block_list* target,int x,int y,int skill_id,struct skill_unit* out_unit, int flag) {
-	int m,bx,by;
+struct skill_unit* map_find_skill_unit_oncell(struct block_list* target,int16 x,int16 y,uint16 skill_id,struct skill_unit* out_unit, int flag) {
+	int16 m,bx,by;
 	struct block_list *bl;
 	struct skill_unit *unit;
 	m = target->m;
@@ -532,7 +533,7 @@ struct skill_unit* map_find_skill_unit_oncell(struct block_list* target,int x,in
 /*==========================================
  * Adapted from foreachinarea for an easier invocation. [Skotlex]
  *------------------------------------------*/
-int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int type, ...)
+int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...)
 {
 	int bx, by, m;
 	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
@@ -561,7 +562,7 @@ int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_lis
 				}
 			}
 		}
-	
+
 	if( type&BL_MOB )
 		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
 			for(bx=x0/BLOCK_SIZE;bx<=x1/BLOCK_SIZE;bx++) {
@@ -597,7 +598,7 @@ int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_lis
 /*==========================================
  * Same as foreachinrange, but there must be a shoot-able range between center and target to be counted in. [Skotlex]
  *------------------------------------------*/
-int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block_list* center, int range, int type,...)
+int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block_list* center, int16 range, int type,...)
 {
 	int bx, by, m;
 	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
@@ -605,7 +606,7 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
 	int blockcount = bl_list_count, i;
 	int x0, x1, y0, y1;
 	va_list ap;
-	
+
 	m = center->m;
 	if ( m < 0 )
 		return 0;
@@ -668,22 +669,22 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
  * Apply *func with ... arguments for the range.
  * @type = BL_PC/BL_MOB etc..
  *------------------------------------------*/
-int map_foreachinarea(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int y1, int type, ...)
+int map_foreachinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
 {
 	int bx, by;
 	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
 	struct block_list *bl;
 	int blockcount = bl_list_count, i;
 	va_list ap;
-	
+
 	if ( m < 0 )
 		return 0;
-	
+
 	if ( x1 < x0 )
 		swap(x0, x1);
 	if ( y1 < y0 )
 		swap(y0, y1);
-	
+
 	x0 = max(x0, 0);
 	y0 = max(y0, 0);
 	x1 = min(x1, map[ m ].xs - 1);
@@ -722,7 +723,7 @@ int map_foreachinarea(int (*func)(struct block_list*,va_list), int m, int x0, in
 /*==========================================
  * Adapted from forcountinarea for an easier invocation. [pakpil]
  *------------------------------------------*/
-int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int count, int type, ...)
+int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int count, int type, ...)
 {
 	int bx, by, m;
 	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
@@ -730,7 +731,7 @@ int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_li
 	int blockcount = bl_list_count, i;
 	int x0, x1, y0, y1;
 	va_list ap;
-	
+
 	m = center->m;
 	x0 = max(center->x - range, 0);
 	y0 = max(center->y - range, 0);
@@ -784,22 +785,22 @@ int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_li
 	bl_list_count = blockcount;
 	return returnCount;	//[Skotlex]
 }
-int map_forcountinarea(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int y1, int count, int type, ...)
+int map_forcountinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, ...)
 {
 	int bx, by;
 	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
 	struct block_list *bl;
 	int blockcount = bl_list_count, i;
 	va_list ap;
-	
+
 	if ( m < 0 )
 		return 0;
-	
+
 	if ( x1 < x0 )
 		swap(x0, x1);
 	if ( y1 < y0 )
 		swap(y0, y1);
-	
+
 	x0 = max(x0, 0);
 	y0 = max(y0, 0);
 	x1 = min(x1, map[ m ].xs - 1);
@@ -844,7 +845,7 @@ int map_forcountinarea(int (*func)(struct block_list*,va_list), int m, int x0, i
  * Move bl and do func* with va_list while moving.
  * Mouvement is set by dx dy wich are distance in x and y
  *------------------------------------------*/
-int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int dx, int dy, int type, ...)
+int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int16 dx, int16 dy, int type, ...)
 {
 	int bx, by, m;
 	int returnCount = 0;  //total sum of returned values of func() [Skotlex]
@@ -855,7 +856,7 @@ int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_
 
 	if ( !range ) return 0;
 	if ( !dx && !dy ) return 0; //No movement.
-	
+
 	m = center->m;
 
 	x0 = center->x - range;
@@ -867,7 +868,7 @@ int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_
 		swap(x0, x1);
 	if ( y1 < y0 )
 		swap(y0, y1);
-	
+
 	if( dx == 0 || dy == 0 ) {
 		//Movement along one axis only.
 		if( dx == 0 ){
@@ -881,12 +882,12 @@ int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_
 			else //East
 				x1 = x0 + dx - 1;
 		}
-		
+
 		x0 = max(x0, 0);
 		y0 = max(y0, 0);
 		x1 = min(x1, map[ m ].xs - 1);
 		y1 = min(y1, map[ m ].ys - 1);
-		
+
 		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
 			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
 				if ( type&~BL_MOB ) {
@@ -909,12 +910,12 @@ int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_
 			}
 		}
 	} else { // Diagonal movement
-		
+
 		x0 = max(x0, 0);
 		y0 = max(y0, 0);
 		x1 = min(x1, map[ m ].xs - 1);
 		y1 = min(y1, map[ m ].ys - 1);
-		
+
 		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
 			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
 				if ( type & ~BL_MOB ) {
@@ -969,7 +970,7 @@ int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_
 //			 which only checks the exact single x/y passed to it rather than an
 //			 area radius - may be more useful in some instances)
 //
-int map_foreachincell(int (*func)(struct block_list*,va_list), int m, int x, int y, int type, ...)
+int map_foreachincell(int (*func)(struct block_list*,va_list), int16 m, int16 x, int16 y, int type, ...)
 {
 	int bx, by;
 	int returnCount = 0;  //total sum of returned values of func() [Skotlex]
@@ -1012,7 +1013,7 @@ int map_foreachincell(int (*func)(struct block_list*,va_list), int m, int x, int
 /*============================================================
 * For checking a path between two points (x0, y0) and (x1, y1)
 *------------------------------------------------------------*/
-int map_foreachinpath(int (*func)(struct block_list*,va_list),int m,int x0,int y0,int x1,int y1,int range,int length, int type,...)
+int map_foreachinpath(int (*func)(struct block_list*,va_list),int16 m,int16 x0,int16 y0,int16 x1,int16 y1,int16 range,int length, int type,...)
 {
 	int returnCount = 0;  //total sum of returned values of func() [Skotlex]
 //////////////////////////////////////////////////////////////
@@ -1057,7 +1058,7 @@ int map_foreachinpath(int (*func)(struct block_list*,va_list),int m,int x0,int y
 	int k, xi, yi, xu, yu;
 	int mx0 = x0, mx1 = x1, my0 = y0, my1 = y1;
 	va_list ap;
-	
+
 	//Avoid needless calculations by not getting the sqrt right away.
 	#define MAGNITUDE2(x0, y0, x1, y1) ( ( ( x1 ) - ( x0 ) ) * ( ( x1 ) - ( x0 ) ) + ( ( y1 ) - ( y0 ) ) * ( ( y1 ) - ( y0 ) ) )
 
@@ -1113,7 +1114,7 @@ int map_foreachinpath(int (*func)(struct block_list*,va_list),int m,int x0,int y
 						yi = bl->y;
 
 						k = ( xi - x0 ) * ( x1 - x0 ) + ( yi - y0 ) * ( y1 - y0 );
-						
+
 						if ( k < 0 || k > len_limit ) //Since more skills use this, check for ending point as well.
 							continue;
 
@@ -1146,7 +1147,7 @@ int map_foreachinpath(int (*func)(struct block_list*,va_list),int m,int x0,int y
 						xi = bl->x;
 						yi = bl->y;
 						k = ( xi - x0 ) * ( x1 - x0 ) + ( yi - y0 ) * ( y1 - y0 );
-						
+
 						if ( k < 0 || k > len_limit )
 							continue;
 
@@ -1190,14 +1191,14 @@ int map_foreachinpath(int (*func)(struct block_list*,va_list),int m,int x0,int y
 }
 
 // Copy of map_foreachincell, but applied to the whole map. [Skotlex]
-int map_foreachinmap(int (*func)(struct block_list*,va_list), int m, int type,...)
+int map_foreachinmap(int (*func)(struct block_list*,va_list), int16 m, int type,...)
 {
 	int b, bsize;
 	int returnCount = 0;  //total sum of returned values of func() [Skotlex]
 	struct block_list *bl;
 	int blockcount = bl_list_count, i;
 	va_list ap;
-	
+
 	bsize = map[ m ].bxs * map[ m ].bys;
 
 	if( type&~BL_MOB )
@@ -1286,15 +1287,15 @@ int map_clearflooritem_timer(int tid, unsigned int tick, int id, intptr_t data)
 	return 0;
 }
 
-/* 
+/*
  * clears a single bl item out of the bazooonga.
  */
 void map_clearflooritem(struct block_list *bl) {
 	struct flooritem_data* fitem = (struct flooritem_data*)bl;
-	
+
 	if( fitem->cleartimer )
 		delete_timer(fitem->cleartimer,map_clearflooritem_timer);
-	
+
 	clif_clearflooritem(fitem, 0);
 	map_deliddb(&fitem->bl);
 	map_delblock(&fitem->bl);
@@ -1306,7 +1307,7 @@ void map_clearflooritem(struct block_list *bl) {
  * to place an BL_ITEM object. Scan area is 9x9, returns 1 on success.
  * x and y are modified with the target cell when successful.
  *------------------------------------------*/
-int map_searchrandfreecell(int m,int *x,int *y,int stack) {
+int map_searchrandfreecell(int16 m,int16 *x,int16 *y,int stack) {
 	int free_cell,i,j;
 	int free_cells[9][2];
 
@@ -1351,7 +1352,7 @@ static int map_count_sub(struct block_list *bl,va_list ap)
  * &2 = the target should be able to walk to the target tile.
  * &4 = there shouldn't be any players around the target tile (use the no_spawn_on_player setting)
  *------------------------------------------*/
-int map_search_freecell(struct block_list *src, int m, short *x,short *y, int rx, int ry, int flag)
+int map_search_freecell(struct block_list *src, int16 m, int16 *x,int16 *y, int16 rx, int16 ry, int flag)
 {
 	int tries, spawn=0;
 	int bx, by;
@@ -1424,7 +1425,7 @@ int map_search_freecell(struct block_list *src, int m, short *x,short *y, int rx
  * @first_charid, @second_charid, @third_charid, looting priority
  * @flag: &1 MVP item. &2 do stacking check.
  *------------------------------------------*/
-int map_addflooritem(struct item *item_data,int amount,int m,int x,int y,int first_charid,int second_charid,int third_charid,int flags)
+int map_addflooritem(struct item *item_data,int amount,int16 m,int16 x,int16 y,int first_charid,int second_charid,int third_charid,int flags)
 {
 	int r;
 	struct flooritem_data *fitem=NULL;
@@ -1706,7 +1707,7 @@ int map_quit(struct map_session_data *sd) {
 
 	if( map[sd->bl.m].instance_id )
 	{ // Avoid map conflicts and warnings on next login
-		int m;
+		int16 m;
 		struct point *pt;
 		if( map[sd->bl.m].save.map )
 			pt = &map[sd->bl.m].save;
@@ -1865,7 +1866,7 @@ bool map_blid_exists( int id ) {
 /*==========================================
  * Convext Mirror
  *------------------------------------------*/
-struct mob_data * map_getmob_boss(int m)
+struct mob_data * map_getmob_boss(int16 m)
 {
 	DBIterator* iter;
 	struct mob_data *md = NULL;
@@ -2154,7 +2155,7 @@ bool mapit_exists(struct s_mapiterator* mapit)
 /*==========================================
  * Add npc-bl to id_db, basically register npc to map
  *------------------------------------------*/
-bool map_addnpc(int m,struct npc_data *nd)
+bool map_addnpc(int16 m,struct npc_data *nd)
 {
 	nullpo_ret(nd);
 
@@ -2190,7 +2191,7 @@ int map_addmobtolist(unsigned short m, struct spawn_data *spawn)
 	return -1;
 }
 
-void map_spawnmobs(int m)
+void map_spawnmobs(int16 m)
 {
 	int i, k=0;
 	if (map[m].mob_delete_timer != INVALID_TIMER)
@@ -2242,7 +2243,7 @@ int map_removemobs_sub(struct block_list *bl, va_list ap)
 int map_removemobs_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	int count;
-	const int m = id;
+	const int16 m = id;
 
 	if (m < 0 || m >= MAX_MAP_PER_SERVER)
 	{	//Incorrect map id!
@@ -2266,7 +2267,7 @@ int map_removemobs_timer(int tid, unsigned int tick, int id, intptr_t data)
 	return 1;
 }
 
-void map_removemobs(int m)
+void map_removemobs(int16 m)
 {
 	if (map[m].mob_delete_timer != INVALID_TIMER) // should never happen
 		return; //Mobs are already scheduled for removal
@@ -2277,7 +2278,7 @@ void map_removemobs(int m)
 /*==========================================
  * Hookup, get map_id from map_name
  *------------------------------------------*/
-int map_mapname2mapid(const char* name)
+int16 map_mapname2mapid(const char* name)
 {
 	unsigned short map_index;
 	map_index = mapindex_name2id(name);
@@ -2289,7 +2290,7 @@ int map_mapname2mapid(const char* name)
 /*==========================================
  * Returns the map of the given mapindex. [Skotlex]
  *------------------------------------------*/
-int map_mapindex2mapid(unsigned short mapindex)
+int16 map_mapindex2mapid(unsigned short mapindex)
 {
 	struct map_data *md=NULL;
 
@@ -2340,9 +2341,9 @@ int map_check_dir(int s_dir,int t_dir)
 /*==========================================
  * Returns the direction of the given cell, relative to 'src'
  *------------------------------------------*/
-uint8 map_calc_dir(struct block_list* src, int x, int y)
+uint8 map_calc_dir(struct block_list* src, int16 x, int16 y)
 {
-	unsigned char dir = 0;
+	uint8 dir = 0;
 	int dx, dy;
 
 	nullpo_ret(src);
@@ -2386,7 +2387,7 @@ uint8 map_calc_dir(struct block_list* src, int x, int y)
  * Randomizes target cell x,y to a random walkable cell that
  * has the same distance from object as given coordinates do. [Skotlex]
  *------------------------------------------*/
-int map_random_dir(struct block_list *bl, short *x, short *y)
+int map_random_dir(struct block_list *bl, int16 *x, int16 *y)
 {
 	short xi = *x-bl->x;
 	short yi = *y-bl->y;
@@ -2451,12 +2452,12 @@ static int map_cell2gat(struct mapcell cell)
 /*==========================================
  * Confirm if celltype in (m,x,y) match the one given in cellchk
  *------------------------------------------*/
-int map_getcell(int m,int x,int y,cell_chk cellchk)
+int map_getcell(int16 m,int16 x,int16 y,cell_chk cellchk)
 {
 	return (m < 0 || m >= MAX_MAP_PER_SERVER) ? 0 : map_getcellp(&map[m],x,y,cellchk);
 }
 
-int map_getcellp(struct map_data* m,int x,int y,cell_chk cellchk)
+int map_getcellp(struct map_data* m,int16 x,int16 y,cell_chk cellchk)
 {
 	struct mapcell cell;
 
@@ -2533,7 +2534,7 @@ int map_getcellp(struct map_data* m,int x,int y,cell_chk cellchk)
  * 'cell' - which flag to modify
  * 'flag' - true = on, false = off
  *------------------------------------------*/
-void map_setcell(int m, int x, int y, cell_t cell, bool flag)
+void map_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag)
 {
 	int j;
 
@@ -2560,7 +2561,7 @@ void map_setcell(int m, int x, int y, cell_t cell, bool flag)
 	}
 }
 
-void map_setgatcell(int m, int x, int y, int gat)
+void map_setgatcell(int16 m, int16 x, int16 y, int gat)
 {
 	int j;
 	struct mapcell cell;
@@ -2581,7 +2582,7 @@ void map_setgatcell(int m, int x, int y, int gat)
  *------------------------------------------*/
 static DBMap* iwall_db;
 
-void map_iwall_nextxy(int x, int y, int dir, int pos, int *x1, int *y1)
+void map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1)
 {
 	if( dir == 0 || dir == 4 )
 		*x1 = x; // Keep X
@@ -2598,10 +2599,11 @@ void map_iwall_nextxy(int x, int y, int dir, int pos, int *x1, int *y1)
 		*y1 = y + pos;
 }
 
-bool map_iwall_set(int m, int x, int y, int size, int dir, bool shootable, const char* wall_name)
+bool map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char* wall_name)
 {
 	struct iwall_data *iwall;
-	int i, x1 = 0, y1 = 0;
+	int i;
+	int16 x1 = 0, y1 = 0;
 
 	if( size < 1 || !wall_name )
 		return false;
@@ -2646,7 +2648,7 @@ void map_iwall_get(struct map_session_data *sd)
 {
 	struct iwall_data *iwall;
 	DBIterator* iter;
-	int x1, y1;
+	int16 x1, y1;
 	int i;
 
 	if( map[sd->bl.m].iwall_num < 1 )
@@ -2670,7 +2672,7 @@ void map_iwall_get(struct map_session_data *sd)
 void map_iwall_remove(const char *wall_name)
 {
 	struct iwall_data *iwall;
-	int i, x1, y1;
+	int16 i, x1, y1;
 
 	if( (iwall = (struct iwall_data *)strdb_get(iwall_db, wall_name)) == NULL )
 		return; // Nothing to do
@@ -3111,16 +3113,16 @@ int parse_console(const char* buf)
 	char type[64];
 	char command[64];
 	char map[64];
-	int x = 0;
-	int y = 0;
-	int m;
+	int16 x = 0;
+	int16 y = 0;
+	int16 m;
 	int n;
 	struct map_session_data sd;
 
 	memset(&sd, 0, sizeof(struct map_session_data));
 	strcpy(sd.status.name, "console");
 
-	if( ( n = sscanf(buf, "%63[^:]:%63[^:]:%63s %d %d[^\n]", type, command, map, &x, &y) ) < 5 )
+	if( ( n = sscanf(buf, "%63[^:]:%63[^:]:%63s %hd %hd[^\n]", type, command, map, &x, &y) ) < 5 )
 	{
 		if( ( n = sscanf(buf, "%63[^:]:%63[^\n]", type, command) ) < 2 )
 		{

src/map/map.h

@@ -310,7 +310,7 @@ enum auto_trigger_flag {
 struct block_list {
 	struct block_list *next,*prev;
 	int id;
-	short m,x,y;
+	int16 m,x,y;
 	enum bl_type type;
 };
 
@@ -496,14 +496,14 @@ struct iwall_data {
 
 struct map_data {
 	char name[MAP_NAME_LENGTH];
-	unsigned short index; // The map index used by the mapindex* functions.
+	uint16 index; // The map index used by the mapindex* functions.
 	struct mapcell* cell; // Holds the information of each map cell (NULL if the map is not on this map-server).
 	struct block_list **block;
 	struct block_list **block_mob;
-	int m;
-	short xs,ys; // map dimensions (in cells)
-	short bxs,bys; // map dimensions (in blocks)
-	short bgscore_lion, bgscore_eagle; // Battleground ScoreBoard
+	int16 m;
+	int16 xs,ys; // map dimensions (in cells)
+	int16 bxs,bys; // map dimensions (in blocks)
+	int16 bgscore_lion, bgscore_eagle; // Battleground ScoreBoard
 	int npc_num;
 	int users;
 	int users_pvp;
@@ -598,10 +598,10 @@ struct map_data_other_server {
 	uint16 port;
 };
 
-int map_getcell(int,int,int,cell_chk);
-int map_getcellp(struct map_data*,int,int,cell_chk);
-void map_setcell(int m, int x, int y, cell_t cell, bool flag);
-void map_setgatcell(int m, int x, int y, int gat);
+int map_getcell(int16 m,int16 x,int16 y,cell_chk cellchk);
+int map_getcellp(struct map_data* m,int16 x,int16 y,cell_chk cellchk);
+void map_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag);
+void map_setgatcell(int16 m, int16 x, int16 y, int gat);
 
 extern struct map_data map[];
 extern int map_num;
@@ -635,31 +635,31 @@ int map_freeblock_unlock(void);
 int map_addblock(struct block_list* bl);
 int map_delblock(struct block_list* bl);
 int map_moveblock(struct block_list *, int, int, unsigned int);
-int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int type, ...);
-int map_foreachinshootrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int type, ...);
-int map_foreachinarea(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int y1, int type, ...);
-int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int count, int type, ...);
-int map_forcountinarea(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int y1, int count, int type, ...);
-int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int dx, int dy, int type, ...);
-int map_foreachincell(int (*func)(struct block_list*,va_list), int m, int x, int y, int type, ...);
-int map_foreachinpath(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int y1, int range, int length, int type, ...);
-int map_foreachinmap(int (*func)(struct block_list*,va_list), int m, int type, ...);
+int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...);
+int map_foreachinshootrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...);
+int map_foreachinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...);
+int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int count, int type, ...);
+int map_forcountinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, ...);
+int map_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int16 dx, int16 dy, int type, ...);
+int map_foreachincell(int (*func)(struct block_list*,va_list), int16 m, int16 x, int16 y, int type, ...);
+int map_foreachinpath(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, ...);
+int map_foreachinmap(int (*func)(struct block_list*,va_list), int16 m, int type, ...);
 //blocklist nb in one cell
-int map_count_oncell(int m,int x,int y,int type);
-struct skill_unit *map_find_skill_unit_oncell(struct block_list *,int x,int y,int skill_id,struct skill_unit *, int flag);
+int map_count_oncell(int16 m,int16 x,int16 y,int type);
+struct skill_unit *map_find_skill_unit_oncell(struct block_list *,int16 x,int16 y,uint16 skill_id,struct skill_unit *, int flag);
 // search and creation
 int map_get_new_object_id(void);
-int map_search_freecell(struct block_list *src, int m, short *x, short *y, int rx, int ry, int flag);
+int map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag);
 //
 int map_quit(struct map_session_data *);
 // npc
-bool map_addnpc(int,struct npc_data *);
+bool map_addnpc(int16 m,struct npc_data *);
 
 // map item
 int map_clearflooritem_timer(int tid, unsigned int tick, int id, intptr_t data);
 int map_removemobs_timer(int tid, unsigned int tick, int id, intptr_t data);
 void map_clearflooritem(struct block_list* bl);
-int map_addflooritem(struct item *item_data,int amount,int m,int x,int y,int first_charid,int second_charid,int third_charid,int flags);
+int map_addflooritem(struct item *item_data,int amount,int16 m,int16 x,int16 y,int first_charid,int second_charid,int third_charid,int flags);
 
 // player to map session
 void map_addnickdb(int charid, const char* nick);
@@ -678,8 +678,8 @@ struct block_list * map_id2bl(int id);
 bool map_blid_exists( int id );
 
 #define map_id2index(id) map[(id)].index
-int map_mapindex2mapid(unsigned short mapindex);
-int map_mapname2mapid(const char* name);
+int16 map_mapindex2mapid(unsigned short mapindex);
+int16 map_mapname2mapid(const char* name);
 int map_mapname2ipport(unsigned short name, uint32* ip, uint16* port);
 int map_setipport(unsigned short map, uint32 ip, uint16 port);
 int map_eraseipport(unsigned short map, uint32 ip, uint16 port);
@@ -692,7 +692,7 @@ void map_foreachnpc(int (*func)(struct npc_data* nd, va_list args), ...);
 void map_foreachregen(int (*func)(struct block_list* bl, va_list args), ...);
 void map_foreachiddb(int (*func)(struct block_list* bl, va_list args), ...);
 struct map_session_data * map_nick2sd(const char*);
-struct mob_data * map_getmob_boss(int m);
+struct mob_data * map_getmob_boss(int16 m);
 struct mob_data * map_id2boss(int id);
 
 // reload config file looking only for npcs
@@ -719,7 +719,7 @@ bool                    mapit_exists(struct s_mapiterator* mapit);
 #define mapit_geteachiddb() mapit_alloc(MAPIT_NORMAL,BL_ALL)
 
 int map_check_dir(int s_dir,int t_dir);
-unsigned char map_calc_dir( struct block_list *src,int x,int y);
+uint8 map_calc_dir( struct block_list *src,int16 x,int16 y);
 int map_random_dir(struct block_list *bl, short *x, short *y); // [Skotlex]
 
 int cleanup_sub(struct block_list *bl, va_list ap);
@@ -727,13 +727,13 @@ int cleanup_sub(struct block_list *bl, va_list ap);
 int map_delmap(char* mapname);
 void map_flags_init(void);
 
-bool map_iwall_set(int m, int x, int y, int size, int dir, bool shootable, const char* wall_name);
+bool map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char* wall_name);
 void map_iwall_get(struct map_session_data *sd);
 void map_iwall_remove(const char *wall_name);
 
 int map_addmobtolist(unsigned short m, struct spawn_data *spawn);	// [Wizputer]
-void map_spawnmobs(int); // [Wizputer]
-void map_removemobs(int); // [Wizputer]
+void map_spawnmobs(int16 m); // [Wizputer]
+void map_removemobs(int16 m); // [Wizputer]
 void do_reconnect_map(void); //Invoked on map-char reconnection [Skotlex]
 void map_addmap2db(struct map_data *m);
 void map_removemapdb(struct map_data *m);

src/map/mercenary.c

@@ -384,7 +384,7 @@ int mercenary_kills(struct mercenary_data *md)
 	return 0;
 }
 
-int mercenary_checkskill(struct mercenary_data *md, int skill_id)
+int mercenary_checkskill(struct mercenary_data *md, uint16 skill_id)
 {
 	int i = skill_id - MC_SKILLBASE;
 
@@ -464,7 +464,7 @@ static bool read_mercenary_skilldb_sub(char* str[], int columns, int current)
 {// <merc id>,<skill id>,<skill level>
 	struct s_mercenary_db *db;
 	int i, class_;
-	int skillid, skilllv;
+	uint16 skill_id, skill_lv;
 
 	class_ = atoi(str[0]);
 	ARR_FIND(0, MAX_MERCENARY_CLASS, i, class_ == mercenary_db[i].class_);
@@ -474,19 +474,19 @@ static bool read_mercenary_skilldb_sub(char* str[], int columns, int current)
 		return false;
 	}
 	
-	skillid = atoi(str[1]);
-	if( skillid < MC_SKILLBASE || skillid >= MC_SKILLBASE + MAX_MERCSKILL )
+	skill_id = atoi(str[1]);
+	if( skill_id < MC_SKILLBASE || skill_id >= MC_SKILLBASE + MAX_MERCSKILL )
 	{
-		ShowError("read_mercenary_skilldb : Skill %d out of range.\n", skillid);
+		ShowError("read_mercenary_skilldb : Skill %d out of range.\n", skill_id);
 		return false;
 	}
 
 	db = &mercenary_db[i];
-	skilllv = atoi(str[2]);
+	skill_lv = atoi(str[2]);
 
-	i = skillid - MC_SKILLBASE;
-	db->skill[i].id = skillid;
-	db->skill[i].lv = skilllv;
+	i = skill_id - MC_SKILLBASE;
+	db->skill[i].id = skill_id;
+	db->skill[i].lv = skill_lv;
 
 	return true;
 }

src/map/mercenary.h

@@ -70,7 +70,7 @@ int mercenary_get_calls(struct mercenary_data *md);
 int mercenary_set_calls(struct mercenary_data *md, int value);
 int mercenary_kills(struct mercenary_data *md);
 
-int mercenary_checkskill(struct mercenary_data *md, int skill_id);
+int mercenary_checkskill(struct mercenary_data *md, uint16 skill_id);
 
 /**
  * atcommand.c required

src/map/mob.c

@@ -90,7 +90,7 @@ const int mob_splendide[5] = { 1991, 1992, 1993, 1994, 1995 };
  *------------------------------------------*/
 static int mob_makedummymobdb(int);
 static int mob_spawn_guardian_sub(int tid, unsigned int tick, int id, intptr_t data);
-int mob_skillid2skillidx(int class_,int skillid);
+int mob_skill_id2skill_idx(int class_,uint16 skill_id);
 
 /*==========================================
  * Mob is searched with a name.
@@ -169,7 +169,7 @@ void mvptomb_destroy(struct mob_data *md) {
 	struct npc_data *nd;
 
 	if ( (nd = map_id2nd(md->tomb_nid)) ) {
-		int m, i;
+		int16 m, i;
 
 		m = nd->bl.m;
 
@@ -285,7 +285,7 @@ struct mob_data* mob_spawn_dataset(struct spawn_data *data)
 		md->lootitem = (struct item *)aCalloc(LOOTITEM_SIZE,sizeof(struct item));
 	md->spawn_timer = INVALID_TIMER;
 	md->deletetimer = INVALID_TIMER;
-	md->skillidx = -1;
+	md->skill_idx = -1;
 	status_set_viewdata(&md->bl, md->class_);
 	status_change_init(&md->bl);
 	unit_dataset(&md->bl);
@@ -420,7 +420,7 @@ bool mob_ksprotected (struct block_list *src, struct block_list *target)
 	return false;
 }
 
-struct mob_data *mob_once_spawn_sub(struct block_list *bl, int m, short x, short y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai)
+struct mob_data *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)
 {
 	struct spawn_data data;
 
@@ -462,7 +462,7 @@ struct mob_data *mob_once_spawn_sub(struct block_list *bl, int m, short x, short
 /*==========================================
  * Spawn a single mob on the specified coordinates.
  *------------------------------------------*/
-int mob_once_spawn(struct map_session_data* sd, int m, short x, short y, const char* mobname, int class_, int amount, const char* event, unsigned int size, unsigned int ai)
+int 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)
 {
 	struct mob_data* md = NULL;
 	int count, lv;
@@ -514,7 +514,7 @@ int mob_once_spawn(struct map_session_data* sd, int m, short x, short y, const c
 /*==========================================
  * Spawn mobs in the specified area.
  *------------------------------------------*/
-int mob_once_spawn_area(struct map_session_data* sd, int m, int x0, int y0, int x1, int y1, const char* mobname, int class_, int amount, const char* event, unsigned int size, unsigned int ai)
+int 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)
 {
 	int i, max, id = 0;
 	int lx = -1, ly = -1;
@@ -624,7 +624,7 @@ int mob_spawn_guardian(const char* mapname, short x, short y, const char* mobnam
 	struct spawn_data data;
 	struct guild *g=NULL;
 	struct guild_castle *gc;
-	int m;
+	int16 m;
 	memset(&data, 0, sizeof(struct spawn_data));
 	data.num = 1;
 
@@ -727,7 +727,7 @@ int mob_spawn_bg(const char* mapname, short x, short y, const char* mobname, int
 {
 	struct mob_data *md = NULL;
 	struct spawn_data data;
-	int m;
+	int16 m;
 
 	if( (m = map_mapname2mapid(mapname)) < 0 )
 	{
@@ -2858,7 +2858,7 @@ int mob_countslave(struct block_list *bl)
 /*==========================================
  * Summons amount slaves contained in the value[5] array using round-robin. [adapted by Skotlex]
  *------------------------------------------*/
-int mob_summonslave(struct mob_data *md2,int *value,int amount,int skill_id)
+int mob_summonslave(struct mob_data *md2,int *value,int amount,uint16 skill_id)
 {
 	struct mob_data *md;
 	struct spawn_data data;
@@ -2954,10 +2954,10 @@ int mob_summonslave(struct mob_data *md2,int *value,int amount,int skill_id)
 }
 
 /*==========================================
- * MOBskill lookup (get skillindex through skillid)
+ * MOBskill lookup (get skillindex through skill_id)
  * Returns -1 if not found.
  *------------------------------------------*/
-int mob_skillid2skillidx(int class_,int skillid)
+int mob_skill_id2skill_idx(int class_,uint16 skill_id)
 {
 	int i, max = mob_db(class_)->maxskill;
 	struct mob_skill *ms=mob_db(class_)->skill;
@@ -2965,7 +2965,7 @@ int mob_skillid2skillidx(int class_,int skillid)
 	if(ms==NULL)
 		return -1;
 
-	ARR_FIND( 0, max, i, ms[i].skill_id == skillid );
+	ARR_FIND( 0, max, i, ms[i].skill_id == skill_id );
 	return ( i < max ) ? i : -1;
 }
 
@@ -3159,7 +3159,7 @@ int mobskill_use(struct mob_data *md, unsigned int tick, int event)
 				case MSC_ATTACKPCGE:	// attack pc >= num
 					flag = (unit_counttargeted(&md->bl) >= c2); break;
 				case MSC_AFTERSKILL:
-					flag = (md->ud.skillid == c2); break;
+					flag = (md->ud.skill_id == c2); break;
 				case MSC_RUDEATTACKED:
 					flag = (md->state.attacked_count >= RUDE_ATTACKED_COUNT);
 					if (flag) md->state.attacked_count = 0;	//Rude attacked count should be reset after the skill condition is met. Thanks to Komurka [Skotlex]
@@ -3217,7 +3217,7 @@ int mobskill_use(struct mob_data *md, unsigned int tick, int event)
 					(ms[i].target-MST_AROUND5) +1;
 				map_search_freecell(&md->bl, md->bl.m, &x, &y, j, j, 3);
 			}
-			md->skillidx = i;
+			md->skill_idx = i;
 			map_freeblock_lock();
 			if( !battle_check_range(&md->bl,bl,skill_get_range2(&md->bl, ms[i].skill_id,ms[i].skill_lv)) ||
 				!unit_skilluse_pos2(&md->bl, x, y,ms[i].skill_id, ms[i].skill_lv,ms[i].casttime, ms[i].cancel) )
@@ -3255,7 +3255,7 @@ int mobskill_use(struct mob_data *md, unsigned int tick, int event)
 			}
 			if (!bl) continue;
 
-			md->skillidx = i;
+			md->skill_idx = i;
 			map_freeblock_lock();
 			if( !battle_check_range(&md->bl,bl,skill_get_range2(&md->bl, ms[i].skill_id,ms[i].skill_lv)) ||
 				!unit_skilluse_id2(&md->bl, bl->id,ms[i].skill_id, ms[i].skill_lv,ms[i].casttime, ms[i].cancel) )
@@ -3284,7 +3284,7 @@ int mobskill_use(struct mob_data *md, unsigned int tick, int event)
 		return 1;
 	}
 	//No skill was used.
-	md->skillidx = -1;
+	md->skill_idx = -1;
 	return 0;
 }
 /*==========================================
@@ -3335,7 +3335,7 @@ int mob_is_clone(int class_)
 //If mode is not passed, a default aggressive mode is used.
 //If master_id is passed, clone is attached to him.
 //Returns: ID of newly crafted copy.
-int mob_clone_spawn(struct map_session_data *sd, int m, int x, int y, const char *event, int master_id, int mode, int flag, unsigned int duration)
+int mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, int mode, int flag, unsigned int duration)
 {
 	int class_;
 	int i,j,inf,skill_id, fd;

src/map/mob.h

@@ -79,7 +79,7 @@ enum ai {
 
 struct mob_skill {
 	enum MobSkillState state;
-	short skill_id,skill_lv;
+	uint16 skill_id,skill_lv;
 	short permillage;
 	int casttime,delay;
 	short cancel;
@@ -175,7 +175,7 @@ struct mob_data {
 	int deletetimer;
 	int master_id,master_dist;
 
-	short skillidx;
+	uint16 skill_idx;
 	unsigned int skilldelay[MAX_MOBSKILL];
 	char npc_event[EVENT_NAME_LENGTH];
 	/**
@@ -238,7 +238,7 @@ struct item_drop {
 	struct item_drop* next;
 };
 struct item_drop_list {
-	int m, x, y;                       // coordinates
+	int16 m, x, y;                       // coordinates
 	int first_charid, second_charid, third_charid; // charid's of players with higher pickup priority
 	struct item_drop* item;            // linked list of drops
 };
@@ -249,19 +249,19 @@ int mobdb_searchname_array(struct mob_db** data, int size, const char *str);
 int mobdb_checkid(const int id);
 struct view_data* mob_get_viewdata(int class_);
 
-struct mob_data *mob_once_spawn_sub(struct block_list *bl, int m,
+struct mob_data *mob_once_spawn_sub(struct block_list *bl, int16 m,
 	short x, short y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai);
 
-int mob_once_spawn(struct map_session_data* sd, int m, short x, short y,
+int 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);
 
-int mob_once_spawn_area(struct map_session_data* sd, int m,
-	int x0, int y0, int x1, int y1, const char* mobname, int class_, int amount, const char* event, unsigned int size, unsigned int ai);
+int 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);
 
 bool mob_ksprotected (struct block_list *src, struct block_list *target);
 
-int mob_spawn_guardian(const char* mapname, short x, short y, const char* mobname, int class_, const char* event, int guardian, bool has_index);	// Spawning Guardians [Valaris]
-int mob_spawn_bg(const char* mapname, short x, short y, const char* mobname, int class_, const char* event, unsigned int bg_id);
+int mob_spawn_guardian(const char* mapname, int16 x, int16 y, const char* mobname, int class_, const char* event, int guardian, bool has_index);	// Spawning Guardians [Valaris]
+int mob_spawn_bg(const char* mapname, int16 x, int16 y, const char* mobname, int class_, const char* event, unsigned int bg_id);
 int mob_guardian_guildchange(struct mob_data *md); //Change Guardian's ownership. [Skotlex]
 
 int mob_randomwalk(struct mob_data *md,unsigned int tick);
@@ -302,13 +302,13 @@ int mobskill_use(struct mob_data *md,unsigned int tick,int event);
 int mobskill_event(struct mob_data *md,struct block_list *src,unsigned int tick, int flag);
 int mobskill_castend_id( int tid, unsigned int tick, int id,int data );
 int mobskill_castend_pos( int tid, unsigned int tick, int id,int data );
-int mob_summonslave(struct mob_data *md2,int *value,int amount,int skill_id);
+int mob_summonslave(struct mob_data *md2,int *value,int amount,uint16 skill_id);
 int mob_countslave(struct block_list *bl);
 int mob_count_sub(struct block_list *bl, va_list ap);
 
 int mob_is_clone(int class_);
 
-int mob_clone_spawn(struct map_session_data *sd, int m, int x, int y, const char *event, int master_id, int mode, int flag, unsigned int duration);
+int mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, int mode, int flag, unsigned int duration);
 int mob_clone_delete(struct mob_data *md);
 
 void mob_reload(void);

src/map/npc.c

@@ -874,7 +874,7 @@ int npc_touchnext_areanpc(struct map_session_data* sd, bool leavemap)
 /*==========================================
  * Exec OnTouch for player if in range of area event
  *------------------------------------------*/
-int npc_touch_areanpc(struct map_session_data* sd, int m, int x, int y)
+int npc_touch_areanpc(struct map_session_data* sd, int16 m, int16 x, int16 y)
 {
 	int xs,ys;
 	int f = 1;
@@ -1023,7 +1023,7 @@ int npc_touch_areanpc2(struct mob_data *md)
 //Flag determines the type of object to check for:
 //&1: NPC Warps
 //&2: NPCs with on-touch events.
-int npc_check_areanpc(int flag, int m, int x, int y, int range)
+int npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range)
 {
 	int i;
 	int x0,y0,x1,y1;
@@ -1734,7 +1734,7 @@ int npc_selllist(struct map_session_data* sd, int n, unsigned short* item_list)
 //This doesn't remove it from map_db
 int npc_remove_map(struct npc_data* nd)
 {
-	int m,i;
+	int16 m,i;
 	nullpo_retr(1, nd);
 
 	if(nd->bl.prev == NULL || nd->bl.m < 0)
@@ -2045,11 +2045,11 @@ struct npc_data* npc_add_warp(char* name, short from_mapid, short from_x, short
 	nd->bl.m = from_mapid;
 	nd->bl.x = from_x;
 	nd->bl.y = from_y;
-	
+
 	safestrncpy(nd->exname, name, ARRAYLENGTH(nd->exname));
 	if (npc_name2id(nd->exname) != NULL)
 		flag = 1;
-	
+
 	if (flag == 1)
 		snprintf(nd->exname, ARRAYLENGTH(nd->exname), "warp_%d_%d_%d", from_mapid, from_x, from_y);
 
@@ -2652,7 +2652,7 @@ const char* npc_parse_duplicate(char* w1, char* w2, char* w3, char* w4, const ch
 	return end;
 }
 
-int npc_duplicate4instance(struct npc_data *snd, int m) {
+int npc_duplicate4instance(struct npc_data *snd, int16 m) {
 	char newname[NAME_LENGTH];
 
 	if( map[m].instance_id == 0 )
@@ -2728,7 +2728,7 @@ int npc_duplicate4instance(struct npc_data *snd, int m) {
 //Set mapcell CELL_NPC to trigger event later
 void npc_setcells(struct npc_data* nd)
 {
-	int m = nd->bl.m, x = nd->bl.x, y = nd->bl.y, xs, ys;
+	int16 m = nd->bl.m, x = nd->bl.x, y = nd->bl.y, xs, ys;
 	int i,j;
 
 	switch(nd->subtype)
@@ -2768,7 +2768,7 @@ int npc_unsetcells_sub(struct block_list* bl, va_list ap)
 
 void npc_unsetcells(struct npc_data* nd)
 {
-	int m = nd->bl.m, x = nd->bl.x, y = nd->bl.y, xs, ys;
+	int16 m = nd->bl.m, x = nd->bl.x, y = nd->bl.y, xs, ys;
 	int i,j, x0, x1, y0, y1;
 
 	if (nd->subtype == WARP) {
@@ -2798,9 +2798,9 @@ void npc_unsetcells(struct npc_data* nd)
 	map_foreachinarea( npc_unsetcells_sub, m, x0, y0, x1, y1, BL_NPC, nd->bl.id );
 }
 
-void npc_movenpc(struct npc_data* nd, int x, int y)
+void npc_movenpc(struct npc_data* nd, int16 x, int16 y)
 {
-	const int m = nd->bl.m;
+	const int16 m = nd->bl.m;
 	if (m < 0 || nd->bl.prev == NULL) return;	//Not on a map.
 
 	x = cap_value(x, 0, map[m].xs-1);
@@ -3013,19 +3013,19 @@ static const char* npc_parse_mob(char* w1, char* w2, char* w3, char* w4, const c
 		ShowError("npc_parse_mob: Invalid number of monsters %d, must be inside the range [1,1000] (file '%s', line '%d').\n", num, filepath, strline(buffer,start-buffer));
 		return strchr(start,'\n');// skip and continue
 	}
-	
+
 	if( (mob.state.size < 0 || mob.state.size > 2) && size != -1 )
 	{
 		ShowError("npc_parse_mob: Invalid size number %d for mob ID %d (file '%s', line '%d').\n", mob.state.size, class_, filepath, strline(buffer, start - buffer));
 		return strchr(start, '\n');
 	}
-	
+
 	if( (mob.state.ai < 0 || mob.state.ai > 4) && ai != -1 )
 	{
 		ShowError("npc_parse_mob: Invalid ai %d for mob ID %d (file '%s', line '%d').\n", mob.state.ai, class_, filepath, strline(buffer, start - buffer));
 		return strchr(start, '\n');
 	}
-	
+
 	if( (mob_lv == 0 || mob_lv > MAX_LEVEL) && mob_lv != -1 )
 	{
 		ShowError("npc_parse_mob: Invalid level %d for mob ID %d (file '%s', line '%d').\n", mob_lv, class_, filepath, strline(buffer, start - buffer));
@@ -3140,7 +3140,7 @@ static const char* npc_parse_mob(char* w1, char* w2, char* w3, char* w4, const c
  *------------------------------------------*/
 static const char* npc_parse_mapflag(char* w1, char* w2, char* w3, char* w4, const char* start, const char* buffer, const char* filepath)
 {
-	int m;
+	int16 m;
 	char mapname[32];
 	int state = 1;
 
@@ -3405,7 +3405,8 @@ static const char* npc_parse_mapflag(char* w1, char* w2, char* w3, char* w4, con
 //@runOnInit should we exec OnInit when it's done ?
 void npc_parsesrcfile(const char* filepath, bool runOnInit)
 {
-	int m, x, y, lines = 0;
+	int16 m, x, y;
+	int lines = 0;
 	FILE* fp;
 	size_t len;
 	char* buffer;
@@ -3488,7 +3489,7 @@ void npc_parsesrcfile(const char* filepath, bool runOnInit)
 		{// w1 = <map name>,<x>,<y>,<facing>
 			char mapname[MAP_NAME_LENGTH*2];
 			x = y = 0;
-			sscanf(w1,"%23[^,],%d,%d[^,]",mapname,&x,&y);
+			sscanf(w1,"%23[^,],%hd,%hd[^,]",mapname,&x,&y);
 			if( !mapindex_name2id(mapname) )
 			{// Incorrect map, we must skip the script info...
 				ShowError("npc_parsesrcfile: Unknown map '%s' in file '%s', line '%d'. Skipping line...\n", mapname, filepath, strline(buffer,p-buffer));
@@ -3654,14 +3655,14 @@ void npc_clear_pathlist(void) {
 //Clear then reload npcs files
 int npc_reload(void) {
 	struct npc_src_list *nsl;
-	int m, i;
+	int16 m, i;
 	int npc_new_min = npc_id;
 	struct s_mapiterator* iter;
 	struct block_list* bl;
 
 	/* clear guild flag cache */
 	guild_flags_clear();
-	
+
 	npc_clear_pathlist();
 
 	db_clear(npc_path_db);
@@ -3794,7 +3795,7 @@ int do_final_npc(void) {
 
 static void npc_debug_warps_sub(struct npc_data* nd)
 {
-	int m;
+	int16 m;
 	if (nd->bl.type != BL_NPC || nd->subtype != WARP || nd->bl.m < 0)
 		return;
 
@@ -3820,7 +3821,7 @@ static void npc_debug_warps_sub(struct npc_data* nd)
 
 static void npc_debug_warps(void)
 {
-	int m, i;
+	int16 m, i;
 	for (m = 0; m < map_num; m++)
 		for (i = 0; i < map[m].npc_num; i++)
 			npc_debug_warps_sub(map[m].npc[i]);

src/map/npc.h

@@ -113,9 +113,9 @@ struct view_data* npc_get_viewdata(int class_);
 int npc_chat_sub(struct block_list* bl, va_list ap);
 int npc_event_dequeue(struct map_session_data* sd);
 int npc_event(struct map_session_data* sd, const char* eventname, int ontouch);
-int npc_touch_areanpc(struct map_session_data* sd, int m, int x, int y);
+int npc_touch_areanpc(struct map_session_data* sd, int16 m, int16 x, int16 y);
 int npc_touch_areanpc2(struct mob_data *md); // [Skotlex]
-int npc_check_areanpc(int flag, int m, int x, int y, int range);
+int npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range);
 int npc_touchnext_areanpc(struct map_session_data* sd,bool leavemap);
 int npc_click(struct map_session_data* sd, struct npc_data* nd);
 int npc_scriptcont(struct map_session_data* sd, int id);
@@ -129,7 +129,7 @@ int npc_globalmessage(const char* name,const char* mes);
 
 void npc_setcells(struct npc_data* nd);
 void npc_unsetcells(struct npc_data* nd);
-void npc_movenpc(struct npc_data* nd, int x, int y);
+void npc_movenpc(struct npc_data* nd, int16 x, int16 y);
 int npc_enable(const char* name, int flag);
 void npc_setdisplayname(struct npc_data* nd, const char* newname);
 void npc_setclass(struct npc_data* nd, short class_);
@@ -162,7 +162,7 @@ int npc_reload(void);
 void npc_read_event_script(void);
 int npc_script_event(struct map_session_data* sd, enum npce_event type);
 
-int npc_duplicate4instance(struct npc_data *snd, int m);
+int npc_duplicate4instance(struct npc_data *snd, int16 m);
 int npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int points);
 
 extern struct npc_data* fake_nd;

src/map/party.c

@@ -801,7 +801,7 @@ int party_recv_message(int party_id,int account_id,const char *mes,int len)
 	return 0;
 }
 
-int party_skill_check(struct map_session_data *sd, int party_id, int skillid, int skilllv)
+int party_skill_check(struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv)
 {
 	struct party_data *p;
 	struct map_session_data *p_sd;
@@ -809,7 +809,7 @@ int party_skill_check(struct map_session_data *sd, int party_id, int skillid, in
 
 	if(!party_id || (p=party_search(party_id))==NULL)
 		return 0;
-	switch(skillid) {
+	switch(skill_id) {
 		case TK_COUNTER: //Increase Triple Attack rate of Monks.
 			if (!p->state.monk) return 0;
 			break;
@@ -829,12 +829,12 @@ int party_skill_check(struct map_session_data *sd, int party_id, int skillid, in
 			continue;
 		if (sd->bl.m != p_sd->bl.m)
 			continue;
-		switch(skillid) {
+		switch(skill_id) {
 			case TK_COUNTER: //Increase Triple Attack rate of Monks.
 				if((p_sd->class_&MAPID_UPPERMASK) == MAPID_MONK
 					&& pc_checkskill(p_sd,MO_TRIPLEATTACK)) {
 					sc_start4(&p_sd->bl,SC_SKILLRATE_UP,100,MO_TRIPLEATTACK,
-						50+50*skilllv, //+100/150/200% rate
+						50+50*skill_lv, //+100/150/200% rate
 						0,0,skill_get_time(SG_FRIEND, 1));
 				}
 				break;

src/map/party.h

@@ -76,7 +76,7 @@ void party_send_levelup(struct map_session_data *sd);
 int party_send_logout(struct map_session_data *sd);
 int party_send_message(struct map_session_data *sd,const char *mes,int len);
 int party_recv_message(int party_id,int account_id,const char *mes,int len);
-int party_skill_check(struct map_session_data *sd, int party_id, int skillid, int skilllv);
+int party_skill_check(struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv);
 int party_send_xy_clear(struct party_data *p);
 int party_exp_share(struct party_data *p,struct block_list *src,unsigned int base_exp,unsigned int job_exp,int zeny);
 int party_share_loot(struct party_data* p, struct map_session_data* sd, struct item* item_data, int first_charid);

src/map/path.c

@@ -99,7 +99,7 @@ static int pop_heap_path(int *heap,struct tmp_path *tp)
 /*==========================================
  * calculate cost for the specified position
  *------------------------------------------*/
-static int calc_cost(struct tmp_path *p,int x1,int y1)
+static int calc_cost(struct tmp_path *p,int16 x1,int16 y1)
 {
 	int xd = abs(x1 - p->x);
 	int yd = abs(y1 - p->y);
@@ -109,7 +109,7 @@ static int calc_cost(struct tmp_path *p,int x1,int y1)
 /*==========================================
  * attach/adjust path if neccessary
  *------------------------------------------*/
-static int add_path(int *heap,struct tmp_path *tp,int x,int y,int dist,int before,int cost)
+static int add_path(int *heap,struct tmp_path *tp,int16 x,int16 y,int dist,int before,int cost)
 {
 	int i;
 
@@ -149,7 +149,7 @@ static int add_path(int *heap,struct tmp_path *tp,int x,int y,int dist,int befor
  * Find the closest reachable cell, 'count' cells away from (x0,y0) in direction (dx,dy).
  * Income after the coordinates of the blow
  *------------------------------------------*/
-int path_blownpos(int m,int x0,int y0,int dx,int dy,int count)
+int path_blownpos(int16 m,int16 x0,int16 y0,int16 dx,int16 dy,int count)
 {
 	struct map_data *md;
 
@@ -166,7 +166,7 @@ int path_blownpos(int m,int x0,int y0,int dx,int dy,int count)
 		dx=(dx>0)?1:((dx<0)?-1:0);
 		dy=(dy>0)?1:((dy<0)?-1:0);
 	}
-	
+
 	while( count > 0 && (dx != 0 || dy != 0) )
 	{
 		if( !map_getcellp(md,x0+dx,y0+dy,CELL_CHKPASS) )
@@ -197,7 +197,7 @@ int path_blownpos(int m,int x0,int y0,int dx,int dy,int count)
 /*==========================================
  * is ranged attack from (x0,y0) to (x1,y1) possible?
  *------------------------------------------*/
-bool path_search_long(struct shootpath_data *spd,int m,int x0,int y0,int x1,int y1,cell_chk cell)
+bool path_search_long(struct shootpath_data *spd,int16 m,int16 x0,int16 y0,int16 x1,int16 y1,cell_chk cell)
 {
 	int dx, dy;
 	int wx = 0, wy = 0;
@@ -270,7 +270,7 @@ bool path_search_long(struct shootpath_data *spd,int m,int x0,int y0,int x1,int
  * flag: &1 = easy path search only
  * cell: type of obstruction to check for
  *------------------------------------------*/
-bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int flag,cell_chk cell)
+bool path_search(struct walkpath_data *wpd,int16 m,int16 x0,int16 y0,int16 x1,int16 y1,int flag,cell_chk cell)
 {
 	int heap[MAX_HEAP+1];
 	struct tmp_path tp[MAX_WALKPATH*MAX_WALKPATH];
@@ -327,7 +327,7 @@ bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int
 		wpd->path_pos = 0;
 		return true;
 	}
-	
+
 	if( flag&1 )
 		return false;
 
@@ -361,9 +361,9 @@ bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int
 			break;
 
 		// dc[0] : y++ Incremental cost at the time
-		// dc[1] : x-- 
-		// dc[2] : y-- 
-		// dc[3] : x++ 
+		// dc[1] : x--
+		// dc[2] : y--
+		// dc[3] : x++
 
 		if(y < ys && !map_getcellp(md,x  ,y+1,cell)) {
 			f |= 1; dc[0] = (y >= y1 ? 20 : 0);
@@ -396,7 +396,7 @@ bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int
 
 	if( !(x==x1 && y==y1) ) // will never happen...
 		return false;
-	
+
 	for(len=0,i=rp;len<100 && i!=calc_index(x0,y0);i=tp[i].before,len++);
 	if(len==100 || len>=sizeof(wpd->path))
 		return false;
@@ -406,7 +406,7 @@ bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int
 	for(i=rp,j=len-1;j>=0;i=tp[i].before,j--) {
 		int dx  = tp[i].x - tp[tp[i].before].x;
 		int dy  = tp[i].y - tp[tp[i].before].y;
-		int dir;
+		uint8 dir;
 		if( dx == 0 ) {
 			dir = (dy > 0 ? 0 : 4);
 		} else if( dx > 0 ) {
@@ -444,7 +444,7 @@ unsigned int distance(int dx, int dy)
 	//There appears to be something wrong with the aproximation below when either dx/dy is 0! [Skotlex]
 	if ( dx == 0 ) return dy;
 	if ( dy == 0 ) return dx;
-	
+
 	if ( dx < dy )
 	{
 		min = dx;

src/map/path.h

@@ -20,13 +20,13 @@ struct shootpath_data {
 };
 
 // calculates destination cell for knockback
-int path_blownpos(int m,int x0,int y0,int dx,int dy,int count);
+int path_blownpos(int16 m,int16 x0,int16 y0,int16 dx,int16 dy,int count);
 
 // tries to find a walkable path
-bool path_search(struct walkpath_data *wpd,int m,int x0,int y0,int x1,int y1,int flag,cell_chk cell);
+bool path_search(struct walkpath_data *wpd,int16 m,int16 x0,int16 y0,int16 x1,int16 y1,int flag,cell_chk cell);
 
 // tries to find a shootable path
-bool path_search_long(struct shootpath_data *spd,int m,int x0,int y0,int x1,int y1,cell_chk cell);
+bool path_search_long(struct shootpath_data *spd,int16 m,int16 x0,int16 y0,int16 x1,int16 y1,cell_chk cell);
 
 
 // distance related functions

src/map/pc.c

@@ -277,7 +277,7 @@ static int pc_check_banding( struct block_list *bl, va_list ap ) {
 
 	return 0;
 }
-int pc_banding(struct map_session_data *sd, short skill_lv) {
+int pc_banding(struct map_session_data *sd, uint16 skill_lv) {
 	int c;
 	int b_sd[MAX_PARTY]; // In case of a full Royal Guard party.
 	int i, j, hp, extra_hp = 0, tmp_qty = 0, tmp_hp;
@@ -3954,7 +3954,7 @@ int pc_takeitem(struct map_session_data *sd,struct flooritem_data *fitem)
 	nullpo_ret(sd);
 	nullpo_ret(fitem);
 
-	if(!check_distance_bl(&fitem->bl, &sd->bl, 2) && sd->ud.skillid!=BS_GREED)
+	if(!check_distance_bl(&fitem->bl, &sd->bl, 2) && sd->ud.skill_id!=BS_GREED)
 		return 0;	// Distance is too far
 
 	if (sd->status.party_id)
@@ -4502,7 +4502,7 @@ int pc_show_steal(struct block_list *bl,va_list ap)
  *	0 = fail
  *	1 = succes
  *------------------------------------------*/
-int pc_steal_item(struct map_session_data *sd,struct block_list *bl, int lv)
+int pc_steal_item(struct map_session_data *sd,struct block_list *bl, uint16 skill_lv)
 {
 	int i,itemid,flag;
 	double rate;
@@ -4531,7 +4531,7 @@ int pc_steal_item(struct map_session_data *sd,struct block_list *bl, int lv)
 	}
 
 	// base skill success chance (percentual)
-	rate = (sd_status->dex - md_status->dex)/2 + lv*6 + 4;
+	rate = (sd_status->dex - md_status->dex)/2 + skill_lv*6 + 4;
 	rate += sd->bonus.add_steal_rate;
 
 	if( rate < 1 )
@@ -4622,7 +4622,7 @@ int pc_steal_coin(struct map_session_data *sd,struct block_list *target)
 int pc_setpos(struct map_session_data* sd, unsigned short mapindex, int x, int y, clr_type clrtype)
 {
 	struct party_data *p;
-	int m;
+	int16 m;
 
 	nullpo_ret(sd);
 
@@ -4796,7 +4796,7 @@ int pc_setpos(struct map_session_data* sd, unsigned short mapindex, int x, int y
 int pc_randomwarp(struct map_session_data *sd, clr_type type)
 {
 	int x,y,i=0;
-	int m;
+	int16 m;
 
 	nullpo_ret(sd);
 
@@ -4869,9 +4869,9 @@ int pc_memo(struct map_session_data* sd, int pos)
 // Skills
 //
 /*==========================================
- * Return player sd skilllv learned for given skill
+ * Return player sd skill_lv learned for given skill
  *------------------------------------------*/
-int pc_checkskill(struct map_session_data *sd,int skill_id)
+int pc_checkskill(struct map_session_data *sd,uint16 skill_id)
 {
 	if(sd == NULL) return 0;
 	if( skill_id >= GD_SKILLBASE && skill_id < GD_MAX )
@@ -5957,45 +5957,45 @@ int pc_statusup2(struct map_session_data* sd, int type, int val)
 }
 
 /*==========================================
- * Update skilllv for player sd
+ * Update skill_lv for player sd
  * Skill point allocation
  *------------------------------------------*/
-int pc_skillup(struct map_session_data *sd,int skill_num)
+int pc_skillup(struct map_session_data *sd,uint16 skill_id)
 {
 	nullpo_ret(sd);
 
-	if( skill_num >= GD_SKILLBASE && skill_num < GD_SKILLBASE+MAX_GUILDSKILL )
+	if( skill_id >= GD_SKILLBASE && skill_id < GD_SKILLBASE+MAX_GUILDSKILL )
 	{
-		guild_skillup(sd, skill_num);
+		guild_skillup(sd, skill_id);
 		return 0;
 	}
 
-	if( skill_num >= HM_SKILLBASE && skill_num < HM_SKILLBASE+MAX_HOMUNSKILL && sd->hd )
+	if( skill_id >= HM_SKILLBASE && skill_id < HM_SKILLBASE+MAX_HOMUNSKILL && sd->hd )
 	{
-		merc_hom_skillup(sd->hd, skill_num);
+		merc_hom_skillup(sd->hd, skill_id);
 		return 0;
 	}
 
-	if( skill_num < 0 || skill_num >= MAX_SKILL )
+	if( skill_id < 0 || skill_id >= MAX_SKILL )
 		return 0;
 
 	if( sd->status.skill_point > 0 &&
-		sd->status.skill[skill_num].id &&
-		sd->status.skill[skill_num].flag == SKILL_FLAG_PERMANENT && //Don't allow raising while you have granted skills. [Skotlex]
-		sd->status.skill[skill_num].lv < skill_tree_get_max(skill_num, sd->status.class_) )
+		sd->status.skill[skill_id].id &&
+		sd->status.skill[skill_id].flag == SKILL_FLAG_PERMANENT && //Don't allow raising while you have granted skills. [Skotlex]
+		sd->status.skill[skill_id].lv < skill_tree_get_max(skill_id, sd->status.class_) )
 	{
-		sd->status.skill[skill_num].lv++;
+		sd->status.skill[skill_id].lv++;
 		sd->status.skill_point--;
-		if( !skill_get_inf(skill_num) )
+		if( !skill_get_inf(skill_id) )
 			status_calc_pc(sd,0); // Only recalculate for passive skills.
 		else if( sd->status.skill_point == 0 && (sd->class_&MAPID_UPPERMASK) == MAPID_TAEKWON && sd->status.base_level >= 90 && pc_famerank(sd->status.char_id, MAPID_TAEKWON) )
 			pc_calc_skilltree(sd); // Required to grant all TK Ranger skills.
 		else
-			pc_check_skilltree(sd, skill_num); // Check if a new skill can Lvlup
+			pc_check_skilltree(sd, skill_id); // Check if a new skill can Lvlup
 
-		clif_skillup(sd,skill_num);
+		clif_skillup(sd,skill_id);
 		clif_updatestatus(sd,SP_SKILLPOINT);
-		if( skill_num == GN_REMODELING_CART ) /* cart weight info was updated by status_calc_pc */
+		if( skill_id == GN_REMODELING_CART ) /* cart weight info was updated by status_calc_pc */
 			clif_updatestatus(sd,SP_CARTINFO);
 		if (!pc_has_permission(sd, PC_PERM_ALL_SKILL)) // may skill everything at any time anyways, and this would cause a huge slowdown
 			clif_skillinfoblock(sd);
@@ -6357,12 +6357,12 @@ int pc_resethate(struct map_session_data* sd)
 	return 0;
 }
 
-int pc_skillatk_bonus(struct map_session_data *sd, int skill_num)
+int pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id)
 {
 	int i, bonus = 0;
 	nullpo_ret(sd);
 
-	ARR_FIND(0, ARRAYLENGTH(sd->skillatk), i, sd->skillatk[i].id == skill_num);
+	ARR_FIND(0, ARRAYLENGTH(sd->skillatk), i, sd->skillatk[i].id == skill_id);
 	if( i < ARRAYLENGTH(sd->skillatk) ) bonus = sd->skillatk[i].val;
 
 	if(sd->sc.data[SC_PYROTECHNIC_OPTION] || sd->sc.data[SC_AQUAPLAY_OPTION])
@@ -6371,11 +6371,11 @@ int pc_skillatk_bonus(struct map_session_data *sd, int skill_num)
 	return bonus;
 }
 
-int pc_skillheal_bonus(struct map_session_data *sd, int skill_num) {
+int pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int i, bonus = sd->bonus.add_heal_rate;
 
 	if( bonus ) {
-		switch( skill_num ) {
+		switch( skill_id ) {
 			case AL_HEAL:           if( !(battle_config.skill_add_heal_rate&1) ) bonus = 0; break;
 			case PR_SANCTUARY:      if( !(battle_config.skill_add_heal_rate&2) ) bonus = 0; break;
 			case AM_POTIONPITCHER:  if( !(battle_config.skill_add_heal_rate&4) ) bonus = 0; break;
@@ -6384,7 +6384,7 @@ int pc_skillheal_bonus(struct map_session_data *sd, int skill_num) {
 		}
 	}
 
-	ARR_FIND(0, ARRAYLENGTH(sd->skillheal), i, sd->skillheal[i].id == skill_num);
+	ARR_FIND(0, ARRAYLENGTH(sd->skillheal), i, sd->skillheal[i].id == skill_id);
 
 	if( i < ARRAYLENGTH(sd->skillheal) )
 		bonus += sd->skillheal[i].val;
@@ -6392,10 +6392,10 @@ int pc_skillheal_bonus(struct map_session_data *sd, int skill_num) {
 	return bonus;
 }
 
-int pc_skillheal2_bonus(struct map_session_data *sd, int skill_num) {
+int pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int i, bonus = sd->bonus.add_heal2_rate;
 
-	ARR_FIND(0, ARRAYLENGTH(sd->skillheal2), i, sd->skillheal2[i].id == skill_num);
+	ARR_FIND(0, ARRAYLENGTH(sd->skillheal2), i, sd->skillheal2[i].id == skill_id);
 
 	if( i < ARRAYLENGTH(sd->skillheal2) )
 		bonus += sd->skillheal2[i].val;
@@ -6513,7 +6513,7 @@ int pc_dead(struct map_session_data *sd,struct block_list *src)
 		if( (bg = bg_team_search(sd->bg_id)) != NULL && bg->die_event[0] )
 			npc_event(sd, bg->die_event, 0);
 	}
-	
+
 	// Clear anything NPC-related when you die and was interacting with one.
 	if (sd->npc_id)
 	{
@@ -6525,7 +6525,7 @@ int pc_dead(struct map_session_data *sd,struct block_list *src)
 			sd->state.menu_or_input = 0;
 		if (sd->npc_menu)
 			sd->npc_menu = 0;
-		
+
 		sd->npc_id = 0;
 		if (sd->st && sd->st->state != END)
 			sd->st->state = END;
@@ -7263,12 +7263,12 @@ int pc_jobchange(struct map_session_data *sd,int job, int upper)
 	//Update skill tree.
 	pc_calc_skilltree(sd);
 	clif_skillinfoblock(sd);
-	
+
 	if (sd->ed)
 		elemental_delete(sd->ed, 0);
 	if (sd->state.vending)
 		vending_closevending(sd);
-	
+
 	map_foreachinmap(jobchange_killclone, sd->bl.m, BL_MOB, sd->bl.id);
 
 	//Remove peco/cart/falcon
@@ -9290,14 +9290,14 @@ int pc_split_atoui(char* str, unsigned int* val, char sep, int max)
  *------------------------------------------*/
 static bool pc_readdb_skilltree(char* fields[], int columns, int current)
 {
-	unsigned char joblv = 0, skilllv;
-	unsigned short skillid;
+	unsigned char joblv = 0, skill_lv;
+	uint16 skill_id;
 	int idx, class_;
-	unsigned int i, offset = 3, skillidx;
+	unsigned int i, offset = 3, skill_idx;
 
 	class_  = atoi(fields[0]);
-	skillid = (unsigned short)atoi(fields[1]);
-	skilllv = (unsigned char)atoi(fields[2]);
+	skill_id = (uint16)atoi(fields[1]);
+	skill_lv = (unsigned char)atoi(fields[2]);
 
 	if(columns==4+MAX_PC_SKILL_REQUIRE*2)
 	{// job level requirement extra column
@@ -9313,25 +9313,25 @@ static bool pc_readdb_skilltree(char* fields[], int columns, int current)
 	idx = pc_class2idx(class_);
 
 	//This is to avoid adding two lines for the same skill. [Skotlex]
-	ARR_FIND( 0, MAX_SKILL_TREE, skillidx, skill_tree[idx][skillidx].id == 0 || skill_tree[idx][skillidx].id == skillid );
-	if( skillidx == MAX_SKILL_TREE )
+	ARR_FIND( 0, MAX_SKILL_TREE, skill_idx, skill_tree[idx][skill_idx].id == 0 || skill_tree[idx][skill_idx].id == skill_id );
+	if( skill_idx == MAX_SKILL_TREE )
 	{
-		ShowWarning("pc_readdb_skilltree: Unable to load skill %hu into job %d's tree. Maximum number of skills per class has been reached.\n", skillid, class_);
+		ShowWarning("pc_readdb_skilltree: Unable to load skill %hu into job %d's tree. Maximum number of skills per class has been reached.\n", skill_id, class_);
 		return false;
 	}
-	else if(skill_tree[idx][skillidx].id)
+	else if(skill_tree[idx][skill_idx].id)
 	{
-		ShowNotice("pc_readdb_skilltree: Overwriting skill %hu for job class %d.\n", skillid, class_);
+		ShowNotice("pc_readdb_skilltree: Overwriting skill %hu for job class %d.\n", skill_id, class_);
 	}
 
-	skill_tree[idx][skillidx].id    = skillid;
-	skill_tree[idx][skillidx].max   = skilllv;
-	skill_tree[idx][skillidx].joblv = joblv;
+	skill_tree[idx][skill_idx].id    = skill_id;
+	skill_tree[idx][skill_idx].max   = skill_lv;
+	skill_tree[idx][skill_idx].joblv = joblv;
 
 	for(i = 0; i < MAX_PC_SKILL_REQUIRE; i++)
 	{
-		skill_tree[idx][skillidx].need[i].id = atoi(fields[i*2+offset]);
-		skill_tree[idx][skillidx].need[i].lv = atoi(fields[i*2+offset+1]);
+		skill_tree[idx][skill_idx].need[i].id = atoi(fields[i*2+offset]);
+		skill_tree[idx][skill_idx].need[i].lv = atoi(fields[i*2+offset+1]);
 	}
 	return true;
 }

src/map/pc.h

@@ -199,8 +199,8 @@ struct map_session_data {
 	time_t emotionlasttime; // to limit flood with emotion packets
 
 	short skillitem,skillitemlv;
-	short skillid_old,skilllv_old;
-	short skillid_dance,skilllv_dance;
+	uint16 skill_id_old,skill_lv_old;
+	uint16 skill_id_dance,skill_lv_dance;
 	short cook_mastery; // range: [0,1999] [Inkfish]
 	unsigned char blockskill[MAX_SKILL];
 	int cloneskill_id, reproduceskill_id;
@@ -244,7 +244,7 @@ struct map_session_data {
 	int magic_addele[ELE_MAX];
 	int magic_addrace[RC_MAX];
 	int magic_addsize[3];
-	int magic_atk_ele[ELE_MAX]; 
+	int magic_atk_ele[ELE_MAX];
 	int critaddrace[RC_MAX];
 	int expaddrace[RC_MAX];
 	int ignore_mdef[RC_MAX];
@@ -692,7 +692,7 @@ int pc_isequip(struct map_session_data *sd,int n);
 int pc_equippoint(struct map_session_data *sd,int n);
 int pc_setinventorydata(struct map_session_data *sd);
 
-int pc_checkskill(struct map_session_data *sd,int skill_id);
+int pc_checkskill(struct map_session_data *sd,uint16 skill_id);
 int pc_checkallowskill(struct map_session_data *sd);
 int pc_checkequip(struct map_session_data *sd,int pos);
 
@@ -749,7 +749,7 @@ int pc_skill(struct map_session_data* sd, int id, int level, int flag);
 
 int pc_insert_card(struct map_session_data *sd,int idx_card,int idx_equip);
 
-int pc_steal_item(struct map_session_data *sd,struct block_list *bl, int skilllv);
+int pc_steal_item(struct map_session_data *sd,struct block_list *bl, uint16 skill_lv);
 int pc_steal_coin(struct map_session_data *sd,struct block_list *bl);
 
 int pc_modifybuyvalue(struct map_session_data*,int);
@@ -771,7 +771,7 @@ int pc_gets_status_point(int);
 int pc_need_status_point(struct map_session_data *,int,int);
 int pc_statusup(struct map_session_data*,int);
 int pc_statusup2(struct map_session_data*,int,int);
-int pc_skillup(struct map_session_data*,int);
+int pc_skillup(struct map_session_data*,uint16 skill_id);
 int pc_allskillup(struct map_session_data*);
 int pc_resetlvl(struct map_session_data*,int type);
 int pc_resetstate(struct map_session_data*);
@@ -783,9 +783,9 @@ int pc_unequipitem(struct map_session_data*,int,int);
 int pc_checkitem(struct map_session_data*);
 int pc_useitem(struct map_session_data*,int);
 
-int pc_skillatk_bonus(struct map_session_data *sd, int skill_num);
-int pc_skillheal_bonus(struct map_session_data *sd, int skill_num);
-int pc_skillheal2_bonus(struct map_session_data *sd, int skill_num);
+int pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id);
+int pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id);
+int pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id);
 
 void pc_damage(struct map_session_data *sd,struct block_list *src,unsigned int hp, unsigned int sp);
 int pc_dead(struct map_session_data *sd,struct block_list *src);
@@ -910,7 +910,7 @@ bool pc_isautolooting(struct map_session_data *sd, int nameid);
 
 void pc_overheat(struct map_session_data *sd, int val);
 
-int pc_banding(struct map_session_data *sd, short skill_lv);
+int pc_banding(struct map_session_data *sd, uint16 skill_lv);
 
 void pc_itemcd_do(struct map_session_data *sd, bool load);
 

src/map/script.c

@@ -5036,7 +5036,7 @@ static int buildin_areawarp_sub(struct block_list *bl,va_list ap)
 }
 BUILDIN_FUNC(areawarp)
 {
-	int m, x0,y0,x1,y1, x2,y2,x3=0,y3=0;
+	int16 m, x0,y0,x1,y1, x2,y2,x3=0,y3=0;
 	unsigned int index;
 	const char *str;
 	const char *mapname;
@@ -8132,7 +8132,7 @@ BUILDIN_FUNC(getskilllv)
 BUILDIN_FUNC(getgdskilllv)
 {
 	int guild_id;
-	int skill_id;
+	uint16 skill_id;
 	struct guild* g;
 
 	guild_id = script_getnum(st,2);
@@ -8822,7 +8822,7 @@ BUILDIN_FUNC(monster)
 	unsigned int ai		= AI_NONE;
 
 	struct map_session_data* sd;
-	int m;
+	int16 m;
 
 	if (script_hasdata(st, 8))
 	{
@@ -8929,7 +8929,7 @@ BUILDIN_FUNC(areamonster)
 	unsigned int ai		= AI_NONE;
 
 	struct map_session_data* sd;
-	int m;
+	int16 m;
 
 	if (script_hasdata(st,10))
 	{
@@ -9016,7 +9016,7 @@ static int buildin_killmonster_sub(struct block_list *bl,va_list ap)
 BUILDIN_FUNC(killmonster)
 {
 	const char *mapname,*event;
-	int m,allflag=0;
+	int16 m,allflag=0;
 	mapname=script_getstr(st,2);
 	event=script_getstr(st,3);
 	if(strcmp(event,"All")==0)
@@ -9062,7 +9062,7 @@ static int buildin_killmonsterall_sub(struct block_list *bl,va_list ap)
 BUILDIN_FUNC(killmonsterall)
 {
 	const char *mapname;
-	int m;
+	int16 m;
 	mapname=script_getstr(st,2);
 
 	if( (m = map_mapname2mapid(mapname))<0 )
@@ -9568,7 +9568,7 @@ BUILDIN_FUNC(mapannounce)
 	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 m;
+	int16 m;
 
 	if ((m = map_mapname2mapid(mapname)) < 0)
 		return 0;
@@ -9593,7 +9593,7 @@ BUILDIN_FUNC(areaannounce)
 	int         fontSize  = script_hasdata(st,11) ? script_getnum(st,11) : 12;    // default fontSize
 	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
-	int m;
+	int16 m;
 
 	if ((m = map_mapname2mapid(mapname)) < 0)
 		return 0;
@@ -9677,7 +9677,8 @@ BUILDIN_FUNC(getusersname)
 BUILDIN_FUNC(getmapguildusers)
 {
 	const char *str;
-	int m, gid;
+	int16 m;
+	int gid;
 	int i=0,c=0;
 	struct guild *g = NULL;
 	str=script_getstr(st,2);
@@ -9704,7 +9705,7 @@ BUILDIN_FUNC(getmapguildusers)
 BUILDIN_FUNC(getmapusers)
 {
 	const char *str;
-	int m;
+	int16 m;
 	str=script_getstr(st,2);
 	if( (m=map_mapname2mapid(str))< 0){
 		script_pushint(st,-1);
@@ -9724,7 +9725,7 @@ static int buildin_getareausers_sub(struct block_list *bl,va_list ap)
 BUILDIN_FUNC(getareausers)
 {
 	const char *str;
-	int m,x0,y0,x1,y1,users=0;
+	int16 m,x0,y0,x1,y1,users=0; //doubt we can have more then 32k users on
 	str=script_getstr(st,2);
 	x0=script_getnum(st,3);
 	y0=script_getnum(st,4);
@@ -9756,7 +9757,8 @@ static int buildin_getareadropitem_sub(struct block_list *bl,va_list ap)
 BUILDIN_FUNC(getareadropitem)
 {
 	const char *str;
-	int m,x0,y0,x1,y1,item,amount=0;
+	int16 m,x0,y0,x1,y1;
+	int item,amount=0;
 	struct script_data *data;
 
 	str=script_getstr(st,2);
@@ -10616,7 +10618,7 @@ BUILDIN_FUNC(isloggedin)
  *------------------------------------------*/
 BUILDIN_FUNC(setmapflagnosave)
 {
-	int m,x,y;
+	int16 m,x,y;
 	unsigned short mapindex;
 	const char *str,*str2;
 
@@ -10639,7 +10641,7 @@ BUILDIN_FUNC(setmapflagnosave)
 
 BUILDIN_FUNC(getmapflag)
 {
-	int m,i;
+	int16 m,i;
 	const char *str;
 
 	str=script_getstr(st,2);
@@ -10724,7 +10726,7 @@ static int script_mapflag_pvp_sub(struct block_list *bl,va_list ap) {
 }
 BUILDIN_FUNC(setmapflag)
 {
-	int m,i;
+	int16 m,i;
 	const char *str;
 	int val=0;
 
@@ -10810,7 +10812,7 @@ BUILDIN_FUNC(setmapflag)
 
 BUILDIN_FUNC(removemapflag)
 {
-	int m,i;
+	int16 m,i;
 	const char *str;
 	int val=0;
 
@@ -10896,7 +10898,7 @@ BUILDIN_FUNC(removemapflag)
 
 BUILDIN_FUNC(pvpon)
 {
-	int m;
+	int16 m;
 	const char *str;
 	TBL_PC* sd = NULL;
 	struct s_mapiterator* iter;
@@ -10943,7 +10945,7 @@ static int buildin_pvpoff_sub(struct block_list *bl,va_list ap)
 
 BUILDIN_FUNC(pvpoff)
 {
-	int m;
+	int16 m;
 	const char *str;
 
 	str=script_getstr(st,2);
@@ -10963,7 +10965,7 @@ BUILDIN_FUNC(pvpoff)
 
 BUILDIN_FUNC(gvgon)
 {
-	int m;
+	int16 m;
 	const char *str;
 
 	str=script_getstr(st,2);
@@ -10977,7 +10979,7 @@ BUILDIN_FUNC(gvgon)
 }
 BUILDIN_FUNC(gvgoff)
 {
-	int m;
+	int16 m;
 	const char *str;
 
 	str=script_getstr(st,2);
@@ -11028,7 +11030,7 @@ BUILDIN_FUNC(emotion)
 
 static int buildin_maprespawnguildid_sub_pc(struct map_session_data* sd, va_list ap)
 {
-	int m=va_arg(ap,int);
+	int16 m=va_arg(ap,int);
 	int g_id=va_arg(ap,int);
 	int flag=va_arg(ap,int);
 
@@ -11059,7 +11061,7 @@ BUILDIN_FUNC(maprespawnguildid)
 	int g_id=script_getnum(st,3);
 	int flag=script_getnum(st,4);
 
-	int m=map_mapname2mapid(mapname);
+	int16 m=map_mapname2mapid(mapname);
 
 	if(m == -1)
 		return 0;
@@ -11477,7 +11479,7 @@ static int buildin_mobcount_sub(struct block_list *bl,va_list ap)	// Added by Ro
 BUILDIN_FUNC(mobcount)	// Added by RoVeRT
 {
 	const char *mapname,*event;
-	int m;
+	int16 m;
 	mapname=script_getstr(st,2);
 	event=script_getstr(st,3);
 
@@ -12472,11 +12474,11 @@ BUILDIN_FUNC(skilleffect)
 {
 	TBL_PC *sd;
 
-	int skillid=( script_isstring(st,2) ? skill_name2id(script_getstr(st,2)) : script_getnum(st,2) );
-	int skilllv=script_getnum(st,3);
+	uint16 skill_id=( script_isstring(st,2) ? skill_name2id(script_getstr(st,2)) : script_getnum(st,2) );
+	uint16 skill_lv=script_getnum(st,3);
 	sd=script_rid2sd(st);
 
-	clif_skill_nodamage(&sd->bl,&sd->bl,skillid,skilllv,1);
+	clif_skill_nodamage(&sd->bl,&sd->bl,skill_id,skill_lv,1);
 
 	return 0;
 }
@@ -12490,13 +12492,13 @@ BUILDIN_FUNC(npcskilleffect)
 {
 	struct block_list *bl= map_id2bl(st->oid);
 
-	int skillid=( script_isstring(st,2) ? skill_name2id(script_getstr(st,2)) : script_getnum(st,2) );
-	int skilllv=script_getnum(st,3);
+	uint16 skill_id=( script_isstring(st,2) ? skill_name2id(script_getstr(st,2)) : script_getnum(st,2) );
+	uint16 skill_lv=script_getnum(st,3);
 	int x=script_getnum(st,4);
 	int y=script_getnum(st,5);
 
 	if (bl)
-		clif_skill_poseffect(bl,skillid,skilllv,x,y,gettick());
+		clif_skill_poseffect(bl,skill_id,skill_lv,x,y,gettick());
 
 	return 0;
 }
@@ -15041,7 +15043,7 @@ BUILDIN_FUNC(searchitem)
 int axtoi(const char *hexStg)
 {
 	int n = 0;         // position in string
-	int m = 0;         // position in digit[] to shift
+	int16 m = 0;         // position in digit[] to shift
 	int count;         // loop index
 	int intValue = 0;  // integer value of hex string
 	int digit[11];      // hold values to convert
@@ -15381,8 +15383,8 @@ BUILDIN_FUNC(unitemote)
 BUILDIN_FUNC(unitskilluseid)
 {
 	int unit_id;
-	int skill_id;
-	int skill_lv;
+	uint16 skill_id;
+	uint16 skill_lv;
 	int target_id;
 	struct block_list* bl;
 
@@ -15405,8 +15407,8 @@ BUILDIN_FUNC(unitskilluseid)
 BUILDIN_FUNC(unitskillusepos)
 {
 	int unit_id;
-	int skill_id;
-	int skill_lv;
+	uint16 skill_id;
+	uint16 skill_lv;
 	int skill_x;
 	int skill_y;
 	struct block_list* bl;
@@ -15646,9 +15648,9 @@ BUILDIN_FUNC(openauction)
 /// @see cell_chk* constants in const.txt for the types
 BUILDIN_FUNC(checkcell)
 {
-	int m = map_mapname2mapid(script_getstr(st,2));
-	int x = script_getnum(st,3);
-	int y = script_getnum(st,4);
+	int16 m = map_mapname2mapid(script_getstr(st,2));
+	int16 x = script_getnum(st,3);
+	int16 y = script_getnum(st,4);
 	cell_chk type = (cell_chk)script_getnum(st,5);
 
 	script_pushint(st, map_getcell(m, x, y, type));
@@ -15663,11 +15665,11 @@ BUILDIN_FUNC(checkcell)
 /// @see cell_* constants in const.txt for the types
 BUILDIN_FUNC(setcell)
 {
-	int m = map_mapname2mapid(script_getstr(st,2));
-	int x1 = script_getnum(st,3);
-	int y1 = script_getnum(st,4);
-	int x2 = script_getnum(st,5);
-	int y2 = script_getnum(st,6);
+	int16 m = map_mapname2mapid(script_getstr(st,2));
+	int16 x1 = script_getnum(st,3);
+	int16 y1 = script_getnum(st,4);
+	int16 x2 = script_getnum(st,5);
+	int16 y2 = script_getnum(st,6);
 	cell_t type = (cell_t)script_getnum(st,7);
 	bool flag = (bool)script_getnum(st,8);
 
@@ -16126,7 +16128,8 @@ BUILDIN_FUNC(bg_destroy)
 BUILDIN_FUNC(bg_getareausers)
 {
 	const char *str;
-	int m, x0, y0, x1, y1, bg_id;
+	int16 m, x0, y0, x1, y1;
+	int bg_id;
 	int i = 0, c = 0;
 	struct battleground_data *bg = NULL;
 	struct map_session_data *sd;
@@ -16161,7 +16164,7 @@ BUILDIN_FUNC(bg_getareausers)
 BUILDIN_FUNC(bg_updatescore)
 {
 	const char *str;
-	int m;
+	int16 m;
 
 	str = script_getstr(st,2);
 	if( (m = map_mapname2mapid(str)) < 0 )
@@ -16261,7 +16264,7 @@ BUILDIN_FUNC(instance_destroy)
 BUILDIN_FUNC(instance_attachmap)
 {
 	const char *name;
-	int m;
+	int16 m;
 	int instance_id;
 	bool usebasename = false;
 
@@ -16286,7 +16289,8 @@ BUILDIN_FUNC(instance_detachmap)
 	struct map_session_data *sd;
 	struct party_data *p;
 	const char *str;
-	int m, instance_id;
+	int16 m;
+	int instance_id;
 
 	str = script_getstr(st, 2);
 	if( script_hasdata(st, 3) )
@@ -16452,7 +16456,8 @@ BUILDIN_FUNC(has_instance)
 	struct map_session_data *sd;
 	struct party_data *p;
  	const char *str;
-	int m, instance_id = 0;
+	int16 m;
+	int instance_id = 0;
 
  	str = script_getstr(st, 2);
 	if( script_hasdata(st, 3) )
@@ -16475,7 +16480,8 @@ BUILDIN_FUNC(has_instance)
 BUILDIN_FUNC(instance_warpall)
 {
 	struct map_session_data *pl_sd;
-	int m, i, instance_id;
+	int16 m, i;
+	int instance_id;
 	const char *mapn;
 	int x, y;
 	unsigned short mapindex;
@@ -16587,8 +16593,8 @@ static int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
 	TBL_MOB* md		= (TBL_MOB*)bl;
 	struct block_list *tbl;
 	int mobid		= va_arg(ap,int);
-	int skillid		= va_arg(ap,int);
-	int skilllv		= va_arg(ap,int);
+	uint16 skill_id		= va_arg(ap,int);
+	uint16 skill_lv		= va_arg(ap,int);
 	int casttime	= va_arg(ap,int);
 	int cancel		= va_arg(ap,int);
 	int emotion		= va_arg(ap,int);
@@ -16603,7 +16609,7 @@ static int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
 		case 0: tbl = map_id2bl(md->bl.id); break;
 		case 1: tbl = map_id2bl(md->target_id); break;
 		case 2: tbl = map_id2bl(md->master_id); break;
-		default:tbl = battle_getenemy(&md->bl, DEFAULT_ENEMY_TYPE(md),skill_get_range2(&md->bl, skillid, skilllv)); break;
+		default:tbl = battle_getenemy(&md->bl, DEFAULT_ENEMY_TYPE(md),skill_get_range2(&md->bl, skill_id, skill_lv)); break;
 	}
 
 	if( !tbl )
@@ -16612,10 +16618,10 @@ static int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
 	if( md->ud.skilltimer != INVALID_TIMER ) // Cancel the casting skill.
 		unit_skillcastcancel(bl,0);
 
-	if( skill_get_casttype(skillid) == CAST_GROUND )
-		unit_skilluse_pos2(&md->bl, tbl->x, tbl->y, skillid, skilllv, casttime, cancel);
+	if( skill_get_casttype(skill_id) == CAST_GROUND )
+		unit_skilluse_pos2(&md->bl, tbl->x, tbl->y, skill_id, skill_lv, casttime, cancel);
 	else
-		unit_skilluse_id2(&md->bl, tbl->id, skillid, skilllv, casttime, cancel);
+		unit_skilluse_id2(&md->bl, tbl->id, skill_id, skill_lv, casttime, cancel);
 
 	clif_emotion(&md->bl, emotion);
 
@@ -16627,7 +16633,8 @@ static int buildin_mobuseskill_sub(struct block_list *bl,va_list ap)
 BUILDIN_FUNC(areamobuseskill)
 {
 	struct block_list center;
-	int m,range,mobid,skillid,skilllv,casttime,emotion,target,cancel;
+	int16 m;
+	int range,mobid,skill_id,skill_lv,casttime,emotion,target,cancel;
 
 	if( (m = map_mapname2mapid(script_getstr(st,2))) < 0 )
 	{
@@ -16643,16 +16650,16 @@ BUILDIN_FUNC(areamobuseskill)
 	center.y = script_getnum(st,4);
 	range = script_getnum(st,5);
 	mobid = script_getnum(st,6);
-	skillid = ( script_isstring(st,7) ? skill_name2id(script_getstr(st,7)) : script_getnum(st,7) );
-	if( (skilllv = script_getnum(st,8)) > battle_config.mob_max_skilllvl )
-		skilllv = battle_config.mob_max_skilllvl;
+	skill_id = ( script_isstring(st,7) ? skill_name2id(script_getstr(st,7)) : script_getnum(st,7) );
+	if( (skill_lv = script_getnum(st,8)) > battle_config.mob_max_skilllvl )
+		skill_lv = battle_config.mob_max_skilllvl;
 
 	casttime = script_getnum(st,9);
 	cancel = script_getnum(st,10);
 	emotion = script_getnum(st,11);
 	target = script_getnum(st,12);
 
-	map_foreachinrange(buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skillid, skilllv, casttime, cancel, emotion, target);
+	map_foreachinrange(buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skill_id, skill_lv, casttime, cancel, emotion, target);
 	return 0;
 }
 
@@ -16680,7 +16687,8 @@ BUILDIN_FUNC(progressbar)
 
 BUILDIN_FUNC(pushpc)
 {
-	int direction, cells, dx, dy;
+	uint8 dir;
+	int cells, dx, dy;
 	struct map_session_data* sd;
 
 	if((sd = script_rid2sd(st))==NULL)
@@ -16688,15 +16696,15 @@ BUILDIN_FUNC(pushpc)
 		return 0;
 	}
 
-	direction = script_getnum(st,2);
+	dir = script_getnum(st,2);
 	cells     = script_getnum(st,3);
 
-	if(direction<0 || direction>7)
+	if(dir<0 || dir>7)
 	{
-		ShowWarning("buildin_pushpc: Invalid direction %d specified.\n", direction);
+		ShowWarning("buildin_pushpc: Invalid direction %d specified.\n", dir);
 		script_reportsrc(st);
 
-		direction%= 8;  // trim spin-over
+		dir%= 8;  // trim spin-over
 	}
 
 	if(!cells)
@@ -16705,12 +16713,12 @@ BUILDIN_FUNC(pushpc)
 	}
 	else if(cells<0)
 	{// pushing backwards
-		direction = (direction+4)%8;  // turn around
+		dir = (dir+4)%8;  // turn around
 		cells     = -cells;
 	}
 
-	dx = dirx[direction];
-	dy = diry[direction];
+	dx = dirx[dir];
+	dy = diry[dir];
 
 	unit_blown(&sd->bl, dx, dy, cells, 0);
 	return 0;
@@ -17241,18 +17249,15 @@ static int atcommand_cleanfloor_sub(struct block_list *bl, va_list ap)
 
 BUILDIN_FUNC(cleanmap)
 {
-	const char *map;
-    int m = -1, index = -1;
-    short x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+    const char *map;
+    int16 m = -1;
+    int16 x0 = 0, y0 = 0, x1 = 0, y1 = 0;
 
-	map = script_getstr(st, 2);
-	index = mapindex_name2id(map);
-	if (index)
-		m = map_mapindex2mapid(index);
-        
+    map = script_getstr(st, 2);
+    m = map_mapname2mapid(map);
     if (!m)
         return 1;
-	
+
 	if ((script_lastdata(st) - 2) < 4) {
 		map_foreachinmap(atcommand_cleanfloor_sub, m, BL_ITEM);
 	} else {
@@ -17267,7 +17272,7 @@ BUILDIN_FUNC(cleanmap)
 			return 1;
 		}
 	}
-	
+
 	return 0;
 }
 /* Cast a skill on the attached player.
@@ -17275,7 +17280,7 @@ BUILDIN_FUNC(cleanmap)
  * npcskill "<skill name>", <skill lvl>, <stat point>, <NPC level>; */
 BUILDIN_FUNC(npcskill)
 {
-	unsigned int skill_id;
+	uint16 skill_id;
 	unsigned short skill_level;
 	unsigned int stat_point;
 	unsigned int npc_level;

src/map/skill.h

@@ -132,7 +132,7 @@ struct skill_timerskill {
 	int target_id;
 	int map;
 	short x,y;
-	short skill_id,skill_lv;
+	uint16 skill_id,skill_lv;
 	int type; // a BF_ type (NOTE: some places use this as general-purpose storage...)
 	int flag;
 };
@@ -149,7 +149,7 @@ struct skill_unit_group {
 	unsigned int tick;
 	int limit,interval;
 
-	short skill_id,skill_lv;
+	uint16 skill_id,skill_lv;
 	int val1,val2,val3;
 	char *valstr;
 	int unit_id;
@@ -217,7 +217,7 @@ extern struct s_skill_arrow_db skill_arrow_db[MAX_SKILL_ARROW_DB];
 // Abracadabra database
 
 struct s_skill_abra_db {
-	int skillid;
+	uint16 skill_id;
 	int req_lv;
 	int per;
 };
@@ -231,70 +231,70 @@ int do_final_skill(void);
 
 //Returns the cast type of the skill: ground cast, castend damage, castend no damage
 enum { CAST_GROUND, CAST_DAMAGE, CAST_NODAMAGE };
-int skill_get_casttype(int id); //[Skotlex]
+int skill_get_casttype(uint16 skill_id); //[Skotlex]
 
 // Accessor to the skills database
 //
-int skill_get_index( int id );
-int	skill_get_type( int id );
-int	skill_get_hit( int id );
-int	skill_get_inf( int id );
-int	skill_get_ele( int id , int lv );
-int	skill_get_nk( int id );
-int	skill_get_max( int id );
-int	skill_get_range( int id , int lv );
-int	skill_get_range2(struct block_list *bl, int id, int lv);
-int	skill_get_splash( int id , int lv );
-int	skill_get_hp( int id ,int lv );
-int	skill_get_mhp( int id ,int lv );
-int	skill_get_sp( int id ,int lv );
-int	skill_get_state(int id);
-int	skill_get_zeny( int id ,int lv );
-int	skill_get_num( int id ,int lv );
-int	skill_get_cast( int id ,int lv );
-int	skill_get_delay( int id ,int lv );
-int	skill_get_walkdelay( int id ,int lv );
-int	skill_get_time( int id ,int lv );
-int	skill_get_time2( int id ,int lv );
-int	skill_get_castnodex( int id ,int lv );
-int	skill_get_castdef( int id );
-int	skill_get_weapontype( int id );
-int	skill_get_ammotype( int id );
-int	skill_get_ammo_qty( int id, int lv );
-int	skill_get_nocast( int id );
-int	skill_get_unit_id(int id,int flag);
-int	skill_get_inf2( int id );
-int	skill_get_castcancel( int id );
-int	skill_get_maxcount( int id ,int lv );
-int	skill_get_blewcount( int id ,int lv );
-int	skill_get_unit_flag( int id );
-int	skill_get_unit_target( int id );
-int	skill_tree_get_max( int id, int b_class );	// Celest
-const char*	skill_get_name( int id ); 	// [Skotlex]
-const char*	skill_get_desc( int id ); 	// [Skotlex]
+int	skill_get_index( uint16 skill_id );
+int	skill_get_type( uint16 skill_id );
+int	skill_get_hit( uint16 skill_id );
+int	skill_get_inf( uint16 skill_id );
+int	skill_get_ele( uint16 skill_id , uint16 skill_lv );
+int	skill_get_nk( uint16 skill_id );
+int	skill_get_max( uint16 skill_id );
+int	skill_get_range( uint16 skill_id , uint16 skill_lv );
+int	skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv);
+int	skill_get_splash( uint16 skill_id , uint16 skill_lv );
+int	skill_get_hp( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_mhp( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_sp( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_state(uint16 skill_id);
+int	skill_get_zeny( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_num( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_cast( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_delay( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_walkdelay( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_time( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_time2( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_castnodex( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_castdef( uint16 skill_id );
+int	skill_get_weapontype( uint16 skill_id );
+int	skill_get_ammotype( uint16 skill_id );
+int	skill_get_ammo_qty( uint16 skill_id, uint16 skill_lv );
+int	skill_get_nocast( uint16 skill_id );
+int	skill_get_unit_id(uint16 skill_id,int flag);
+int	skill_get_inf2( uint16 skill_id );
+int	skill_get_castcancel( uint16 skill_id );
+int	skill_get_maxcount( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_blewcount( uint16 skill_id ,uint16 skill_lv );
+int	skill_get_unit_flag( uint16 skill_id );
+int	skill_get_unit_target( uint16 skill_id );
+int	skill_tree_get_max( uint16 skill_id, int b_class );	// Celest
+const char*	skill_get_name( uint16 skill_id ); 	// [Skotlex]
+const char*	skill_get_desc( uint16 skill_id ); 	// [Skotlex]
 
 int skill_name2id(const char* name);
 
 int skill_isammotype(struct map_session_data *sd, int skill);
 int skill_castend_id(int tid, unsigned int tick, int id, intptr_t data);
 int skill_castend_pos(int tid, unsigned int tick, int id, intptr_t data);
-int skill_castend_map( struct map_session_data *sd,short skill_num, const char *map);
+int skill_castend_map( struct map_session_data *sd,uint16 skill_id, const char *map);
 
 int skill_cleartimerskill(struct block_list *src);
-int skill_addtimerskill(struct block_list *src,unsigned int tick,int target,int x,int y,int skill_id,int skill_lv,int type,int flag);
+int skill_addtimerskill(struct block_list *src,unsigned int tick,int target,int x,int y,uint16 skill_id,uint16 skill_lv,int type,int flag);
 
 // Results? Added
-int skill_additional_effect( struct block_list* src, struct block_list *bl,int skillid,int skilllv,int attack_type,int dmg_lv,unsigned int tick);
-int skill_counter_additional_effect( struct block_list* src, struct block_list *bl,int skillid,int skilllv,int attack_type,unsigned int tick);
-int skill_blown(struct block_list* src, struct block_list* target, int count, int direction, int flag);
+int skill_additional_effect( struct block_list* src, struct block_list *bl,uint16 skill_id,uint16 skill_lv,int attack_type,int dmg_lv,unsigned int tick);
+int skill_counter_additional_effect( struct block_list* src, struct block_list *bl,uint16 skill_id,uint16 skill_lv,int attack_type,unsigned int tick);
+int skill_blown(struct block_list* src, struct block_list* target, int count, int8 dir, int flag);
 int skill_break_equip(struct block_list *bl, unsigned short where, int rate, int flag);
 int skill_strip_equip(struct block_list *bl, unsigned short where, int rate, int lv, int time);
 // Skills unit
 struct skill_unit_group* skill_id2group(int group_id);
-struct skill_unit_group *skill_unitsetting(struct block_list* src, short skillid, short skilllv, short x, short y, int flag);
+struct skill_unit_group *skill_unitsetting(struct block_list* src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag);
 struct skill_unit *skill_initunit (struct skill_unit_group *group, int idx, int x, int y, int val1, int val2);
 int skill_delunit(struct skill_unit *unit);
-struct skill_unit_group *skill_initunitgroup(struct block_list* src, int count, short skillid, short skilllv, int unit_id, int limit, int interval);
+struct skill_unit_group *skill_initunitgroup(struct block_list* src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval);
 int skill_delunitgroup_(struct skill_unit_group *group, const char* file, int line, const char* func);
 #define skill_delunitgroup(group) skill_delunitgroup_(group,__FILE__,__LINE__,__func__)
 int skill_clear_unitgroup(struct block_list *src);
@@ -303,12 +303,12 @@ void ext_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, unsig
 
 int skill_unit_ondamaged(struct skill_unit *src,struct block_list *bl,int damage,unsigned int tick);
 
-int skill_castfix( struct block_list *bl, int skill_id, int skill_lv);
+int skill_castfix( struct block_list *bl, uint16 skill_id, uint16 skill_lv);
 int skill_castfix_sc( struct block_list *bl, int time);
 #ifdef RENEWAL_CAST
-int skill_vfcastfix( struct block_list *bl, double time, int skill_id, int skill_lv);
+int skill_vfcastfix( struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv);
 #endif
-int skill_delayfix( struct block_list *bl, int skill_id, int skill_lv);
+int skill_delayfix( struct block_list *bl, uint16 skill_id, uint16 skill_lv);
 
 // Skill conditions check and remove [Inkfish]
 int skill_check_condition_castbegin(struct map_session_data *sd, short skill, short lv);
@@ -316,12 +316,12 @@ int skill_check_condition_castend(struct map_session_data *sd, short skill, shor
 int skill_consume_requirement(struct map_session_data *sd, short skill, short lv, short type);
 struct skill_condition skill_get_requirement(struct map_session_data *sd, short skill, short lv);
 
-int skill_check_pc_partner(struct map_session_data *sd, short skill_id, short* skill_lv, int range, int cast_flag);
+int skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, short* skill_lv, int range, int cast_flag);
 // -- moonsoul	(added skill_check_unit_cell)
-int skill_check_unit_cell(int skillid,int m,int x,int y,int unit_id);
+int skill_check_unit_cell(uint16 skill_id,int16 m,int16 x,int16 y,int unit_id);
 int skill_unit_out_all( struct block_list *bl,unsigned int tick,int range);
 int skill_unit_move(struct block_list *bl,unsigned int tick,int flag);
-int skill_unit_move_unit_group( struct skill_unit_group *group, int m,int dx,int dy);
+int skill_unit_move_unit_group( struct skill_unit_group *group, int16 m,int16 dx,int16 dy);
 
 struct skill_unit_group *skill_check_dancing( struct block_list *src );
 
@@ -332,40 +332,40 @@ int skill_guildaura_sub (struct map_session_data* sd, int id, int strvit, int ag
 int skill_castcancel(struct block_list *bl,int type);
 
 int skill_sit (struct map_session_data *sd, int type);
-void skill_brandishspear(struct block_list* src, struct block_list* bl, int skillid, int skilllv, unsigned int tick, int flag);
+void skill_brandishspear(struct block_list* src, struct block_list* bl, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag);
 void skill_repairweapon(struct map_session_data *sd, int idx);
 void skill_identify(struct map_session_data *sd,int idx);
 void skill_weaponrefine(struct map_session_data *sd,int idx); // [Celest]
-int skill_autospell(struct map_session_data *md,int skillid);
+int skill_autospell(struct map_session_data *md,uint16 skill_id);
 
-int skill_calc_heal(struct block_list *src, struct block_list *target, int skill_id, int skill_lv, bool heal);
+int skill_calc_heal(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal);
 
 bool skill_check_cloaking(struct block_list *bl, struct status_change_entry *sce);
 
 // Abnormal status
 int skill_enchant_elemental_end(struct block_list *bl, int type);
-int skillnotok(int skillid, struct map_session_data *sd);
-int skillnotok_hom(int skillid, struct homun_data *hd);
-int skillnotok_mercenary(int skillid, struct mercenary_data *md);
+int skillnotok(uint16 skill_id, struct map_session_data *sd);
+int skillnotok_hom(uint16 skill_id, struct homun_data *hd);
+int skillnotok_mercenary(uint16 skill_id, struct mercenary_data *md);
 
 int skill_chastle_mob_changetarget(struct block_list *bl,va_list ap);
 
 // Item creation
 int skill_can_produce_mix( struct map_session_data *sd, int nameid, int trigger, int qty);
-int skill_produce_mix( struct map_session_data *sd, int skill_id, int nameid, int slot1, int slot2, int slot3, int qty );
+int skill_produce_mix( struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty );
 
 int skill_arrow_create( struct map_session_data *sd,int nameid);
 
 // skills for the mob
-int skill_castend_nodamage_id( struct block_list *src, struct block_list *bl,int skillid,int skilllv,unsigned int tick,int flag );
-int skill_castend_damage_id( struct block_list* src, struct block_list *bl,int skillid,int skilllv,unsigned int tick,int flag );
-int skill_castend_pos2( struct block_list *src, int x,int y,int skillid,int skilllv,unsigned int tick,int flag);
+int skill_castend_nodamage_id( struct block_list *src, struct block_list *bl,uint16 skill_id,uint16 skill_lv,unsigned int tick,int flag );
+int skill_castend_damage_id( struct block_list* src, struct block_list *bl,uint16 skill_id,uint16 skill_lv,unsigned int tick,int flag );
+int skill_castend_pos2( struct block_list *src, int x,int y,uint16 skill_id,uint16 skill_lv,unsigned int tick,int flag);
 
-int skill_blockpc_start_(struct map_session_data*, int, int, bool);
-int skill_blockhomun_start (struct homun_data*,int,int);
-int skill_blockmerc_start (struct mercenary_data*,int,int);
+int skill_blockpc_start_(struct map_session_data*, uint16 skill_id, int, bool);
+int skill_blockhomun_start (struct homun_data*,uint16 skill_id,int);
+int skill_blockmerc_start (struct mercenary_data*,uint16 skill_id,int);
 
-#define skill_blockpc_start(sd, skillid, tick) skill_blockpc_start_( sd, skillid, tick, false )
+#define skill_blockpc_start(sd, skill_id, tick) skill_blockpc_start_( sd, skill_id, tick, false )
 
 // (Epoque:) To-do: replace this macro with some sort of skill tree check (rather than hard-coded skill names)
 #define skill_ischangesex(id) ( \
@@ -373,7 +373,7 @@ int skill_blockmerc_start (struct mercenary_data*,int,int);
 	((id) >= CG_LONGINGFREEDOM && (id) <= CG_TAROTCARD)     || ((id) >= WA_SWING_DANCE && (id) <= WM_UNLIMITED_HUMMING_VOICE))
 
 // Skill action, (return dmg,heal)
-int skill_attack( int attack_type, struct block_list* src, struct block_list *dsrc,struct block_list *bl,int skillid,int skilllv,unsigned int tick,int flag );
+int skill_attack( int attack_type, struct block_list* src, struct block_list *dsrc,struct block_list *bl,uint16 skill_id,uint16 skill_lv,unsigned int tick,int flag );
 
 void skill_reload(void);
 
@@ -1802,7 +1802,7 @@ enum {
 /**
  * Skill Unit Save
  **/
-void skill_usave_add(struct map_session_data * sd, int skill_num, int skill_lv);
+void skill_usave_add(struct map_session_data * sd, uint16 skill_id, uint16 skill_lv);
 void skill_usave_trigger(struct map_session_data *sd);
 /**
  * Skill Cool Downs - load from pc.c when the character logs in
@@ -1819,13 +1819,13 @@ enum wl_spheres {
 	WLS_STONE,
 };
 int skill_spellbook (struct map_session_data *sd, int nameid);
-int skill_block_check(struct block_list *bl, enum sc_type type, int skillid);
+int skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_id);
 /**
  * Guilottine Cross
  **/
 #define MAX_SKILL_MAGICMUSHROOM_DB 23
 struct s_skill_magicmushroom_db {
-	int skillid;
+	uint16 skill_id;
 };
 extern struct s_skill_magicmushroom_db skill_magicmushroom_db[MAX_SKILL_MAGICMUSHROOM_DB];
 /**
@@ -1854,10 +1854,10 @@ enum gx_poison {
 /**
  * Auto Shadow Spell (Shadow Chaser)
  **/
-int skill_select_menu(struct map_session_data *sd,int skill_id);
+int skill_select_menu(struct map_session_data *sd,uint16 skill_id);
 
-int skill_elementalanalysis(struct map_session_data *sd, int n, int type, unsigned short *item_list); // Sorcerer Four Elemental Analisys.
+int skill_elementalanalysis(struct map_session_data *sd, int n, uint16 skill_lv, unsigned short *item_list); // Sorcerer Four Elemental Analisys.
 int skill_changematerial(struct map_session_data *sd, int n, unsigned short *item_list);	// Genetic Change Material.
-int skill_get_elemental_type(int skill_id, int skill_lv);
+int skill_get_elemental_type(uint16 skill_id, uint16 skill_lv);
 
 #endif /* _SKILL_H_ */

src/map/status.c

@@ -92,12 +92,12 @@ static unsigned int StatusChangeStateTable[SC_MAX]; // status -> flags
  **/
 sc_type status_skill2sc(int skill)
 {
-	int sk = skill_get_index(skill);
-	if( sk == 0 ) {
+	int idx = skill_get_index(skill);
+	if( idx == 0 ) {
 		ShowError("status_skill2sc: Unsupported skill id %d\n", skill);
 		return SC_NONE;
 	}
-	return SkillStatusChangeTable[sk];
+	return SkillStatusChangeTable[idx];
 }
 
 /**
@@ -150,11 +150,11 @@ int status_type2relevant_bl_types(int type)
 // 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) set_sc((skill), (sc), (icon), (flag)); if((icon) < SI_MAX) StatusRelevantBLTypes[(icon)] |= BL_SCEFFECT
 
-static void set_sc(int skill, sc_type sc, int icon, unsigned int flag)
+static void set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag)
 {
-	int sk = skill_get_index(skill);
-	if( sk == 0 ) {
-		ShowError("set_sc: Unsupported skill id %d\n", skill);
+	uint16 idx = skill_get_index(skill_id);
+	if( idx == 0 ) {
+		ShowError("set_sc: Unsupported skill id %d\n", skill_id);
 		return;
 	}
 	if( sc < 0 || sc >= SC_MAX ) {
@@ -163,13 +163,13 @@ static void set_sc(int skill, sc_type sc, int icon, unsigned int flag)
 	}
 
 	if( StatusSkillChangeTable[sc] == 0 )
-  		StatusSkillChangeTable[sc] = skill;
+  		StatusSkillChangeTable[sc] = skill_id;
 	if( StatusIconChangeTable[sc] == SI_BLANK )
   		StatusIconChangeTable[sc] = icon;
 	StatusChangeFlagTable[sc] |= flag;
 
-	if( SkillStatusChangeTable[sk] == SC_NONE )
-		SkillStatusChangeTable[sk] = sc;
+	if( SkillStatusChangeTable[idx] == SC_NONE )
+		SkillStatusChangeTable[idx] = sc;
 }
 
 void initChangeTables(void) {
@@ -1533,7 +1533,7 @@ int status_revive(struct block_list *bl, unsigned char per_hp, unsigned char per
  * target MAY Be null, in which case the checks are only to see
  * whether the source can cast or not the skill on the ground.
  *------------------------------------------*/
-int status_check_skilluse(struct block_list *src, struct block_list *target, int skill_num, int flag)
+int status_check_skilluse(struct block_list *src, struct block_list *target, uint16 skill_id, int flag)
 {
 	struct status_data *status;
 	struct status_change *sc=NULL, *tsc;
@@ -1544,7 +1544,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 	if (src && src->type != BL_PC && status_isdead(src))
 		return 0;
 
-	if (!skill_num) { //Normal attack checks.
+	if (!skill_id) { //Normal attack checks.
 		if (!(status->mode&MD_CANATTACK))
 			return 0; //This mode is only needed for melee attacking.
 		//Dead state is not checked for skills as some skills can be used
@@ -1555,7 +1555,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 			return 0;
 	}
 
-	switch( skill_num ) {
+	switch( skill_id ) {
 		case PA_PRESSURE:
 			if( flag && target ) {
 				//Gloria Avoids pretty much everything....
@@ -1572,7 +1572,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 			//Should fail when used on top of Land Protector [Skotlex]
 			if (src && map_getcell(src->m, src->x, src->y, CELL_CHKLANDPROTECTOR)
 				&& !(status->mode&MD_BOSS)
-				&& (src->type != BL_PC || ((TBL_PC*)src)->skillitem != skill_num))
+				&& (src->type != BL_PC || ((TBL_PC*)src)->skillitem != skill_id))
 				return 0;
 			break;
 		default:
@@ -1583,17 +1583,17 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 
 	if( sc && sc->count ) {
 
-		if (skill_num != RK_REFRESH && sc->opt1 >0 && (sc->opt1 != OPT1_CRYSTALIZE && src->type != BL_MOB) && sc->opt1 != OPT1_BURNING && skill_num != SR_GENTLETOUCH_CURE) { //Stuned/Frozen/etc
+		if (skill_id != RK_REFRESH && sc->opt1 >0 && (sc->opt1 != OPT1_CRYSTALIZE && src->type != BL_MOB) && sc->opt1 != OPT1_BURNING && skill_id != SR_GENTLETOUCH_CURE) { //Stuned/Frozen/etc
 			if (flag != 1) //Can't cast, casted stuff can't damage.
 				return 0;
-			if (!(skill_get_inf(skill_num)&INF_GROUND_SKILL))
+			if (!(skill_get_inf(skill_id)&INF_GROUND_SKILL))
 				return 0; //Targetted spells can't come off.
 		}
 
 		if (
-			(sc->data[SC_TRICKDEAD] && skill_num != NV_TRICKDEAD)
+			(sc->data[SC_TRICKDEAD] && skill_id != NV_TRICKDEAD)
 			|| (sc->data[SC_AUTOCOUNTER] && !flag)
-			|| (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF && skill_num != PA_GOSPEL)
+			|| (sc->data[SC_GOSPEL] && sc->data[SC_GOSPEL]->val4 == BCT_SELF && skill_id != PA_GOSPEL)
 			|| (sc->data[SC_GRAVITATION] && sc->data[SC_GRAVITATION]->val3 == BCT_SELF && flag != 2)
 		)
 			return 0;
@@ -1608,26 +1608,26 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 		if (sc->data[SC_BLADESTOP]) {
 			switch (sc->data[SC_BLADESTOP]->val1)
 			{
-				case 5: if (skill_num == MO_EXTREMITYFIST) break;
-				case 4: if (skill_num == MO_CHAINCOMBO) break;
-				case 3: if (skill_num == MO_INVESTIGATE) break;
-				case 2: if (skill_num == MO_FINGEROFFENSIVE) break;
+				case 5: if (skill_id == MO_EXTREMITYFIST) break;
+				case 4: if (skill_id == MO_CHAINCOMBO) break;
+				case 3: if (skill_id == MO_INVESTIGATE) break;
+				case 2: if (skill_id == MO_FINGEROFFENSIVE) break;
 				default: return 0;
 			}
 		}
 
 		if (sc->data[SC_DANCING] && flag!=2) {
-			if( src->type == BL_PC && skill_num >= WA_SWING_DANCE && skill_num <= WM_UNLIMITED_HUMMING_VOICE )
+			if( src->type == BL_PC && skill_id >= WA_SWING_DANCE && skill_id <= WM_UNLIMITED_HUMMING_VOICE )
 			{ // Lvl 5 Lesson or higher allow you use 3rd job skills while dancing.v
 				if( pc_checkskill((TBL_PC*)src,WM_LESSON) < 5 )
 					return 0;
 			} else if(sc->data[SC_LONGING]) { //Allow everything except dancing/re-dancing. [Skotlex]
-				if (skill_num == BD_ENCORE ||
-					skill_get_inf2(skill_num)&(INF2_SONG_DANCE|INF2_ENSEMBLE_SKILL)
+				if (skill_id == BD_ENCORE ||
+					skill_get_inf2(skill_id)&(INF2_SONG_DANCE|INF2_ENSEMBLE_SKILL)
 				)
 					return 0;
 			} else {
-				switch (skill_num) {
+				switch (skill_id) {
 					case BD_ADAPTATION:
 					case CG_LONGINGFREEDOM:
 					case BA_MUSICALSTRIKE:
@@ -1637,33 +1637,33 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 						return 0;
 				}
 			}
-			if ((sc->data[SC_DANCING]->val1&0xFFFF) == CG_HERMODE && skill_num == BD_ADAPTATION)
+			if ((sc->data[SC_DANCING]->val1&0xFFFF) == CG_HERMODE && skill_id == BD_ADAPTATION)
 				return 0;	//Can't amp out of Wand of Hermode :/ [Skotlex]
 		}
 
-		if (skill_num && //Do not block item-casted skills.
-			(src->type != BL_PC || ((TBL_PC*)src)->skillitem != skill_num)
+		if (skill_id && //Do not block item-casted skills.
+			(src->type != BL_PC || ((TBL_PC*)src)->skillitem != skill_id)
 		) {	//Skills blocked through status changes...
 			if (!flag && ( //Blocked only from using the skill (stuff like autospell may still go through
 				sc->cant.cast ||
-				(sc->data[SC_MARIONETTE] && skill_num != CG_MARIONETTE) || //Only skill you can use is marionette again to cancel it
-				(sc->data[SC_MARIONETTE2] && skill_num == CG_MARIONETTE) || //Cannot use marionette if you are being buffed by another
-				(sc->data[SC_STASIS] && skill_block_check(src, SC_STASIS, skill_num)) ||
-				(sc->data[SC_KAGEHUMI] && skill_block_check(src, SC_KAGEHUMI, skill_num))
+				(sc->data[SC_MARIONETTE] && skill_id != CG_MARIONETTE) || //Only skill you can use is marionette again to cancel it
+				(sc->data[SC_MARIONETTE2] && skill_id == CG_MARIONETTE) || //Cannot use marionette if you are being buffed by another
+				(sc->data[SC_STASIS] && skill_block_check(src, SC_STASIS, skill_id)) ||
+				(sc->data[SC_KAGEHUMI] && skill_block_check(src, SC_KAGEHUMI, skill_id))
 			))
 				return 0;
 
 			//Skill blocking.
 			if (
-				(sc->data[SC_VOLCANO] && skill_num == WZ_ICEWALL) ||
-				(sc->data[SC_ROKISWEIL] && skill_num != BD_ADAPTATION) ||
-				(sc->data[SC_HERMODE] && skill_get_inf(skill_num) & INF_SUPPORT_SKILL) ||
+				(sc->data[SC_VOLCANO] && skill_id == WZ_ICEWALL) ||
+				(sc->data[SC_ROKISWEIL] && skill_id != BD_ADAPTATION) ||
+				(sc->data[SC_HERMODE] && skill_get_inf(skill_id) & INF_SUPPORT_SKILL) ||
 				(sc->data[SC_NOCHAT] && sc->data[SC_NOCHAT]->val1&MANNER_NOSKILL)
 			)
 				return 0;
 
 			if( sc->data[SC__MANHOLE] || ((tsc = status_get_sc(target)) && tsc->data[SC__MANHOLE]) ) {
-				switch(skill_num) {//##TODO## make this a flag in skill_db?
+				switch(skill_id) {//##TODO## make this a flag in skill_db?
 					// Skills that can be used even under Man Hole effects.
 					case SC_SHADOWFORM:
 					case SC_STRIPACCESSARY:
@@ -1679,7 +1679,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 	if (sc && sc->option)
 	{
 		if (sc->option&OPTION_HIDE)
-		switch (skill_num) { //Usable skills while hiding.
+		switch (skill_id) { //Usable skills while hiding.
 			case TF_HIDING:
 			case AS_GRIMTOOTH:
 			case RG_BACKSTAP:
@@ -1690,10 +1690,10 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 				break;
 			default:
 				//Non players can use all skills while hidden.
-				if (!skill_num || src->type == BL_PC)
+				if (!skill_id || src->type == BL_PC)
 					return 0;
 		}
-		if (sc->option&OPTION_CHASEWALK && skill_num != ST_CHASEWALK)
+		if (sc->option&OPTION_CHASEWALK && skill_id != ST_CHASEWALK)
 			return 0;
 		if(sc->option&OPTION_MOUNTING)
 			return 0;//New mounts can't attack nor use skills in the client; this check makes it cheat-safe [Ind]
@@ -1706,14 +1706,14 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 
 	if(tsc && tsc->count) {
 		/* attacks in invincible are capped to 1 damage and handled in batte.c; allow spell break and eske for sealed shrine GDB when in INVINCIBLE state. */
-		if( tsc->data[SC_INVINCIBLE] && !tsc->data[SC_INVINCIBLEOFF] && skill_num && !(skill_num&(SA_SPELLBREAKER|SL_SKE)) )
+		if( tsc->data[SC_INVINCIBLE] && !tsc->data[SC_INVINCIBLEOFF] && skill_id && !(skill_id&(SA_SPELLBREAKER|SL_SKE)) )
 			return 0;
-		if(!skill_num && tsc->data[SC_TRICKDEAD])
+		if(!skill_id && tsc->data[SC_TRICKDEAD])
 			return 0;
-		if((skill_num == WZ_STORMGUST || skill_num == WZ_FROSTNOVA || skill_num == NJ_HYOUSYOURAKU)
+		if((skill_id == WZ_STORMGUST || skill_id == WZ_FROSTNOVA || skill_id == NJ_HYOUSYOURAKU)
 			&& tsc->data[SC_FREEZE])
 			return 0;
-		if(skill_num == PR_LEXAETERNA && (tsc->data[SC_FREEZE] || (tsc->data[SC_STONE] && tsc->opt1 == OPT1_STONE)))
+		if(skill_id == PR_LEXAETERNA && (tsc->data[SC_FREEZE] || (tsc->data[SC_STONE] && tsc->opt1 == OPT1_STONE)))
 			return 0;
 	}
 
@@ -1721,7 +1721,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 	hide_flag = flag?OPTION_HIDE:(OPTION_HIDE|OPTION_CLOAK|OPTION_CHASEWALK);
 
  	//You cannot hide from ground skills.
-	if( skill_get_ele(skill_num,1) == ELE_EARTH ) //TODO: Need Skill Lv here :/
+	if( skill_get_ele(skill_id,1) == ELE_EARTH ) //TODO: Need Skill Lv here :/
 		hide_flag &= ~OPTION_HIDE;
 
 	switch( target->type ) {
@@ -1735,7 +1735,7 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 					((sd->special_state.perfect_hiding || !is_detect) ||
 					(tsc->data[SC_CLOAKINGEXCEED] && is_detect)))
 					return 0;
-				if( tsc->data[SC_CAMOUFLAGE] && !(is_boss || is_detect) && !skill_num )
+				if( tsc->data[SC_CAMOUFLAGE] && !(is_boss || is_detect) && !skill_id )
 					return 0;
 				if( tsc->data[SC_STEALTHFIELD] && !is_boss )
 					return 0;
@@ -1749,11 +1749,11 @@ int status_check_skilluse(struct block_list *src, struct block_list *target, int
 		case BL_HOM:
 		case BL_MER:
 		case BL_ELEM:
-			if( target->type == BL_HOM && skill_num && battle_config.hom_setting&0x1 && skill_get_inf(skill_num)&INF_SUPPORT_SKILL && battle_get_master(target) != src )
+			if( target->type == BL_HOM && skill_id && battle_config.hom_setting&0x1 && skill_get_inf(skill_id)&INF_SUPPORT_SKILL && battle_get_master(target) != src )
 				return 0; // Can't use support skills on Homunculus (only Master/Self)
-			if( target->type == BL_MER && (skill_num == PR_ASPERSIO || (skill_num >= SA_FLAMELAUNCHER && skill_num <= SA_SEISMICWEAPON)) && battle_get_master(target) != src )
+			if( target->type == BL_MER && (skill_id == PR_ASPERSIO || (skill_id >= SA_FLAMELAUNCHER && skill_id <= SA_SEISMICWEAPON)) && battle_get_master(target) != src )
 				return 0; // Can't use Weapon endow skills on Mercenary (only Master)
-			if( skill_num == AM_POTIONPITCHER && ( target->type == BL_MER || target->type == BL_ELEM) )
+			if( skill_id == AM_POTIONPITCHER && ( target->type == BL_MER || target->type == BL_ELEM) )
 				return 0; // Can't use Potion Pitcher on Mercenaries
 		default:
 			//Check for chase-walk/hiding/cloaking opponents.
@@ -2038,12 +2038,12 @@ int status_calc_mob_(struct mob_data* md, bool first)
 			md->special_state.ai = 0;
 		if (ud)
 		{	// different levels of HP according to skill level
-			if (ud->skillid == AM_SPHEREMINE) {
-				status->max_hp = 2000 + 400*ud->skilllv;
-			} else if(ud->skillid == KO_ZANZOU){
-				status->max_hp = 3000 + 3000 * ud->skilllv;
+			if (ud->skill_id == AM_SPHEREMINE) {
+				status->max_hp = 2000 + 400*ud->skill_lv;
+			} else if(ud->skill_id == KO_ZANZOU){
+				status->max_hp = 3000 + 3000 * ud->skill_lv;
 			} else { //AM_CANNIBALIZE
-				status->max_hp = 1500 + 200*ud->skilllv + 10*status_get_lv(mbl);
+				status->max_hp = 1500 + 200*ud->skill_lv + 10*status_get_lv(mbl);
 				status->mode|= MD_CANATTACK|MD_AGGRESSIVE;
 			}
 			status->hp = status->max_hp;
@@ -3229,16 +3229,16 @@ int status_calc_elemental_(struct elemental_data *ed, bool first) {
 
 int status_calc_npc_(struct npc_data *nd, bool first) {
 	struct status_data *status = &nd->status;
-	
+
 	if (!nd)
 		return 0;
-	
+
 	if (first) {
 		status->hp = 1;
 		status->sp = 1;
 		status->max_hp = 1;
 		status->max_sp = 1;
-		
+
 		status->def_ele = ELE_NEUTRAL;
 		status->ele_lv = 1;
 		status->race = RC_DEMIHUMAN;
@@ -3254,7 +3254,7 @@ int status_calc_npc_(struct npc_data *nd, bool first) {
 	status->int_= nd->stat_point;
 	status->dex = nd->stat_point;
 	status->luk = nd->stat_point;
-	
+
 	status_calc_misc(&nd->bl, status, nd->level);
 	status_cpy(&nd->status, status);
 
@@ -3309,8 +3309,8 @@ void status_calc_regen(struct block_list *bl, struct status_data *status, struct
 	if( sd && sd->hprecov_rate != 100 )
 		val = val*sd->hprecov_rate/100;
 
-	reg_flag = bl->type == BL_PC ? 0 : 1;	
-		
+	reg_flag = bl->type == BL_PC ? 0 : 1;
+
 	regen->hp = cap_value(val, reg_flag, SHRT_MAX);
 
 	val = 1 + (status->int_/6) + (status->max_sp/100);
@@ -3567,7 +3567,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
 		flag|=SCB_FLEE
 #ifdef RENEWAL
 			|SCB_DEF2
-#endif			
+#endif
 			;
 		if( bl->type&(BL_PC|BL_HOM) )
 			flag |= SCB_ASPD|SCB_DSPD;
@@ -3696,7 +3696,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
 			)
 			status->def2 = status_calc_def2(bl, sc, b_status->def2);
 		else
-			status->def2 = status_calc_def2(bl, sc, b_status->def2 
+			status->def2 = status_calc_def2(bl, sc, b_status->def2
 #ifdef RENEWAL
 			+ (int)( ((float)status->vit/2 + (float)b_status->vit/2) + ((float)status->agi/5 + (float)b_status->agi/5) )
 #else
@@ -3721,7 +3721,7 @@ void status_calc_bl_main(struct block_list *bl, /*enum scb_flag*/int flag)
 			)
 			status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2);
 		else
-			status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2 +(status->int_ - b_status->int_) 
+			status->mdef2 = status_calc_mdef2(bl, sc, b_status->mdef2 +(status->int_ - b_status->int_)
 #ifdef RENEWAL
 			+ (int)( ((float)status->dex/5 - (float)b_status->dex/5) + ((float)status->vit/5 + (float)b_status->vit/5) )
 #else
@@ -4352,7 +4352,7 @@ static unsigned short status_calc_int(struct block_list *bl, struct status_chang
 		int_ -= sc->data[SC_STOMACHACHE]->val1;
 	if(sc->data[SC_KYOUGAKU])
 		int_ -= sc->data[SC_KYOUGAKU]->val2;
-	
+
 	if(sc->data[SC_STRIPHELM])
 		int_ -= int_ * sc->data[SC_STRIPHELM]->val2/100;
 	if(sc->data[SC__STRIPACCESSORY])
@@ -4806,7 +4806,7 @@ static signed short status_calc_flee(struct block_list *bl, struct status_change
 	if( sc->data[SC_SPEARQUICKEN] )
 		flee += 2 * sc->data[SC_SPEARQUICKEN]->val1;
 #endif
-	
+
 	if(sc->data[SC_INCFLEERATE])
 		flee += flee * sc->data[SC_INCFLEERATE]->val1/100;
 	if(sc->data[SC_SPIDERWEB] && sc->data[SC_SPIDERWEB]->val1)
@@ -5090,10 +5090,10 @@ static unsigned short status_calc_speed(struct block_list *bl, struct status_cha
 	if( sc == NULL )
 		return cap_value(speed,10,USHRT_MAX);
 
-	if( sd && sd->ud.skilltimer != INVALID_TIMER && (pc_checkskill(sd,SA_FREECAST) > 0 || sd->ud.skillid == LG_EXEEDBREAK) )
+	if( sd && sd->ud.skilltimer != INVALID_TIMER && (pc_checkskill(sd,SA_FREECAST) > 0 || sd->ud.skill_id == LG_EXEEDBREAK) )
 	{
-		if( sd->ud.skillid == LG_EXEEDBREAK )
-			speed_rate = 100 + 60 - (sd->ud.skilllv * 10);
+		if( sd->ud.skill_id == LG_EXEEDBREAK )
+			speed_rate = 100 + 60 - (sd->ud.skill_lv * 10);
 		else
 			speed_rate = 175 - 5 * pc_checkskill(sd,SA_FREECAST);
 	}
@@ -5834,7 +5834,7 @@ defType status_get_def(struct block_list *bl) {
 	int def = status?status->def:0;
 	ud = unit_bl2ud(bl);
 	if (ud && ud->skilltimer != INVALID_TIMER)
-		def -= def * skill_get_castdef(ud->skillid)/100;
+		def -= def * skill_get_castdef(ud->skill_id)/100;
 
 	return cap_value(def, DEFTYPE_MIN, DEFTYPE_MAX);
 }
@@ -7366,7 +7366,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 		case SC_DANCING:
 			//val1 : Skill ID + LV
 			//val2 : Skill Group of the Dance.
-			//val3 : Brings the skilllv (merged into val1 here)
+			//val3 : Brings the skill_lv (merged into val1 here)
 			//val4 : Partner
 			if (val1 == CG_MOONLIT)
 				clif_status_change(bl,SI_MOONLIT,1,tick,0, 0, 0);
@@ -7734,7 +7734,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 		}
 			break;
 		case SC_KAITE:
-			val2 = 1+val1/5; //Number of bounces: 1 + skilllv/5
+			val2 = 1+val1/5; //Number of bounces: 1 + skill_lv/5
 			break;
 		case SC_KAUPE:
 			switch (val1) {
@@ -7769,7 +7769,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			}
 			break;
 		case SC_EARTHSCROLL:
-			val2 = 11-val1; //Chance to consume: 11-skilllv%
+			val2 = 11-val1; //Chance to consume: 11-skill_lv%
 			break;
 		case SC_RUN:
 			val4 = gettick(); //Store time at which you started running.
@@ -8435,7 +8435,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
 			val3 = MG_FIREBOLT;
 			break;
 		case SC_AQUAPLAY_OPTION:
-			val2 = 40; 
+			val2 = 40;
 			val_flag |= 1|2|4;
 			break;
 		case SC_COOLER_OPTION:
@@ -8598,7 +8598,7 @@ int status_change_start(struct block_list* bl,enum sc_type type,int rate,int val
                         case SC_STYLE_CHANGE: //[Lighta] need real info
                             tick = -1;
                             if(val2 == MH_MD_FIGHTING) val2 = MH_MD_GRAPPLING;
-                            else val2 = MH_MD_FIGHTING; 
+                            else val2 = MH_MD_FIGHTING;
                             break;
 		default:
 			if( calc_flag == SCB_NONE && StatusSkillChangeTable[type] == 0 && StatusIconChangeTable[type] == 0 )
@@ -9476,7 +9476,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
 			sc_start(bl,SC_HALLUCINATIONWALK_POSTDELAY,100,sce->val1,skill_get_time2(GC_HALLUCINATIONWALK,sce->val1));
 			break;
 		case SC_WHITEIMPRISON:
-			{				
+			{
 				struct block_list* src = map_id2bl(sce->val2);
 				if( tid == -1 || !src)
 					break; // Terminated by Damage
@@ -10188,24 +10188,24 @@ int status_change_timer(int tid, unsigned int tick, int id, intptr_t data)
 
 			if( !flag ) { // Random Skill Cast
 				if (sd && !pc_issit(sd)) { //can't cast if sit
-					int mushroom_skillid = 0, i;
+					int mushroom_skill_id = 0, i;
 					unit_stop_attack(bl);
 					unit_skillcastcancel(bl,1);
 					do {
 						i = rnd() % MAX_SKILL_MAGICMUSHROOM_DB;
-						mushroom_skillid = skill_magicmushroom_db[i].skillid;
+						mushroom_skill_id = skill_magicmushroom_db[i].skill_id;
 					}
-					while( mushroom_skillid == 0 );
+					while( mushroom_skill_id == 0 );
 
-					switch( skill_get_casttype(mushroom_skillid) ) { // Magic Mushroom skills are buffs or area damage
+					switch( skill_get_casttype(mushroom_skill_id) ) { // Magic Mushroom skills are buffs or area damage
 						case CAST_GROUND:
-							skill_castend_pos2(bl,bl->x,bl->y,mushroom_skillid,1,tick,0);
+							skill_castend_pos2(bl,bl->x,bl->y,mushroom_skill_id,1,tick,0);
 							break;
 						case CAST_NODAMAGE:
-							skill_castend_nodamage_id(bl,bl,mushroom_skillid,1,tick,0);
+							skill_castend_nodamage_id(bl,bl,mushroom_skill_id,1,tick,0);
 							break;
 						case CAST_DAMAGE:
-							skill_castend_damage_id(bl,bl,mushroom_skillid,1,tick,0);
+							skill_castend_damage_id(bl,bl,mushroom_skill_id,1,tick,0);
 							break;
 					}
 				}
@@ -10356,7 +10356,7 @@ int status_change_timer(int tid, unsigned int tick, int id, intptr_t data)
 	case SC__INVISIBILITY:
 		if( --(sce->val4) >= 0 )
 		{
-			if( !status_charge(bl, 0, (status->sp * 6 - sce->val1) / 100) )// 6% - skilllv.
+			if( !status_charge(bl, 0, (status->sp * 6 - sce->val1) / 100) )// 6% - skill_lv.
 				break;
 			sc_timer_next(1000 + tick, status_change_timer, bl->id, data);
 			return 0;

src/map/status.h

@@ -1800,7 +1800,7 @@ void status_calc_misc(struct block_list *bl, struct status_data *status, int lev
 void status_calc_regen(struct block_list *bl, struct status_data *status, struct regen_data *regen);
 void status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc);
 
-int status_check_skilluse(struct block_list *src, struct block_list *target, int skill_num, int flag); // [Skotlex]
+int status_check_skilluse(struct block_list *src, struct block_list *target, uint16 skill_id, int flag); // [Skotlex]
 int status_check_visibility(struct block_list *src, struct block_list *target); //[Skotlex]
 
 int status_change_spread( struct block_list *src, struct block_list *bl );

src/map/unit.c

@@ -77,7 +77,7 @@ int unit_walktoxy_sub(struct block_list *bl)
 	if (ud->target_to && ud->chaserange>1) {
 		//Generally speaking, the walk path is already to an adjacent tile
 		//so we only need to shorten the path if the range is greater than 1.
-		int dir;
+		uint8 dir;
 		//Trim the last part of the path to account for range,
 		//but always move at least one cell when requested to move.
 		for (i = ud->chaserange*10; i > 0 && ud->walkpath.path_len>1;) {
@@ -212,7 +212,7 @@ static int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data
 			!(ud->walk_count%WALK_SKILL_INTERVAL) &&
 			mobskill_use(md, tick, -1))
 	  	{
-			if (!(ud->skillid == NPC_SELFDESTRUCTION && ud->skilltimer != INVALID_TIMER))
+			if (!(ud->skill_id == NPC_SELFDESTRUCTION && ud->skilltimer != INVALID_TIMER))
 			{	//Skill used, abort walking
 				clif_fixpos(bl); //Fix position as walk has been cancelled.
 				return 0;
@@ -585,7 +585,7 @@ int unit_wugdash(struct block_list *bl, struct map_session_data *sd) {
 //Makes bl attempt to run dist cells away from target. Uses hard-paths.
 int unit_escape(struct block_list *bl, struct block_list *target, short dist)
 {
-	int dir = map_calc_dir(target, bl->x, bl->y);
+	uint8 dir = map_calc_dir(target, bl->x, bl->y);
 	while( dist > 0 && map_getcell(bl->m, bl->x + dist*dirx[dir], bl->y + dist*diry[dir], CELL_CHKNOREACH) )
 		dist--;
 	return ( dist > 0 && unit_walktoxy(bl, bl->x + dist*dirx[dir], bl->y + dist*diry[dir], 0) );
@@ -864,14 +864,14 @@ int unit_stop_walking(struct block_list *bl,int type)
 	return 1;
 }
 
-int unit_skilluse_id(struct block_list *src, int target_id, short skill_num, short skill_lv)
+int unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv)
 {
-	if(skill_num < 0) return 0;
+	if(skill_id < 0) return 0;
 
 	return unit_skilluse_id2(
-		src, target_id, skill_num, skill_lv,
-		skill_castfix(src, skill_num, skill_lv),
-		skill_get_castcancel(skill_num)
+		src, target_id, skill_id, skill_lv,
+		skill_castfix(src, skill_id, skill_lv),
+		skill_get_castcancel(skill_id)
 	);
 }
 
@@ -900,7 +900,7 @@ int unit_can_move(struct block_list *bl)
 	if (!ud)
 		return 0;
 
-	if (ud->skilltimer != INVALID_TIMER && ud->skillid != LG_EXEEDBREAK && (!sd || !pc_checkskill(sd, SA_FREECAST) || skill_get_inf2(ud->skillid)&INF2_GUILD_SKILL))
+	if (ud->skilltimer != INVALID_TIMER && ud->skill_id != LG_EXEEDBREAK && (!sd || !pc_checkskill(sd, SA_FREECAST) || skill_get_inf2(ud->skill_id)&INF2_GUILD_SKILL))
 		return 0; // prevent moving while casting
 
 	if (DIFF_TICK(ud->canmove_tick, gettick()) > 0)
@@ -949,11 +949,11 @@ int unit_resume_running(int tid, unsigned int tick, int id, intptr_t data)
 	TBL_PC * sd = map_id2sd(id);
 
 	if(sd && pc_isridingwug(sd))
-		clif_skill_nodamage(ud->bl,ud->bl,RA_WUGDASH,ud->skilllv,
-			sc_start4(ud->bl,status_skill2sc(RA_WUGDASH),100,ud->skilllv,unit_getdir(ud->bl),0,0,1));
+		clif_skill_nodamage(ud->bl,ud->bl,RA_WUGDASH,ud->skill_lv,
+			sc_start4(ud->bl,status_skill2sc(RA_WUGDASH),100,ud->skill_lv,unit_getdir(ud->bl),0,0,1));
 	else
-		clif_skill_nodamage(ud->bl,ud->bl,TK_RUN,ud->skilllv,
-			sc_start4(ud->bl,status_skill2sc(TK_RUN),100,ud->skilllv,unit_getdir(ud->bl),0,0,0));
+		clif_skill_nodamage(ud->bl,ud->bl,TK_RUN,ud->skill_lv,
+			sc_start4(ud->bl,status_skill2sc(TK_RUN),100,ud->skill_lv,unit_getdir(ud->bl),0,0,0));
 
 	if (sd) clif_walkok(sd);
 
@@ -1009,7 +1009,7 @@ int unit_set_walkdelay(struct block_list *bl, unsigned int tick, int delay, int
 	return 1;
 }
 
-int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, short skill_lv, int casttime, int castcancel)
+int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel)
 {
 	struct unit_data *ud;
 	struct status_data *tstatus;
@@ -1032,20 +1032,20 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 		sc = NULL; //Unneeded
 
 	//temp: used to signal combo-skills right now.
-	if (sc && sc->data[SC_COMBO] && (sc->data[SC_COMBO]->val1 == skill_num ||
-		(sd?skill_check_condition_castbegin(sd,skill_num,skill_lv):0) )) {
+	if (sc && sc->data[SC_COMBO] && (sc->data[SC_COMBO]->val1 == skill_id ||
+		(sd?skill_check_condition_castbegin(sd,skill_id,skill_lv):0) )) {
 		if (sc->data[SC_COMBO]->val2)
 			target_id = sc->data[SC_COMBO]->val2;
 		else
 			target_id = ud->target;
 
-		if( skill_get_inf(skill_num)&INF_SELF_SKILL && skill_get_nk(skill_num)&NK_NO_DAMAGE )// exploit fix
+		if( skill_get_inf(skill_id)&INF_SELF_SKILL && skill_get_nk(skill_id)&NK_NO_DAMAGE )// exploit fix
 			target_id = src->id;
 		temp = 1;
 	} else
 	if ( target_id == src->id &&
-		skill_get_inf(skill_num)&INF_SELF_SKILL &&
-		skill_get_inf2(skill_num)&INF2_NO_TARGET_SELF )
+		skill_get_inf(skill_id)&INF_SELF_SKILL &&
+		skill_get_inf2(skill_id)&INF2_NO_TARGET_SELF )
 	{
 		target_id = ud->target; //Auto-select target. [Skotlex]
 		temp = 1;
@@ -1053,10 +1053,10 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 
 	if (sd) {
 		//Target_id checking.
-		if(skillnotok(skill_num, sd)) // [MouseJstr]
+		if(skillnotok(skill_id, sd)) // [MouseJstr]
 			return 0;
 
-		switch(skill_num)
+		switch(skill_id)
 		{	//Check for skills that auto-select target
 		case MO_CHAINCOMBO:
 			if (sc && sc->data[SC_BLADESTOP]){
@@ -1070,7 +1070,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 				return 0;
 			target = (struct block_list*)map_charid2sd(sd->status.partner_id);
 			if (!target) {
-				clif_skill_fail(sd,skill_num,USESKILL_FAIL_LEVEL,0);
+				clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 				return 0;
 			}
 			break;
@@ -1079,7 +1079,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 			target_id = target->id;
 	}
 	if (src->type==BL_HOM)
-	switch(skill_num)
+	switch(skill_id)
 	{ //Homun-auto-target skills.
 		case HLIF_HEAL:
 		case HLIF_AVOID:
@@ -1100,32 +1100,32 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 		return 0;
 
 	//Normally not needed because clif.c checks for it, but the at/char/script commands don't! [Skotlex]
-	if(ud->skilltimer != INVALID_TIMER && skill_num != SA_CASTCANCEL && skill_num != SO_SPELLFIST)
+	if(ud->skilltimer != INVALID_TIMER && skill_id != SA_CASTCANCEL && skill_id != SO_SPELLFIST)
 		return 0;
 
-	if(skill_get_inf2(skill_num)&INF2_NO_TARGET_SELF && src->id == target_id)
+	if(skill_get_inf2(skill_id)&INF2_NO_TARGET_SELF && src->id == target_id)
 		return 0;
 
-	if(!status_check_skilluse(src, target, skill_num, 0))
+	if(!status_check_skilluse(src, target, skill_id, 0))
 		return 0;
 
 	tstatus = status_get_status_data(target);
 	// Record the status of the previous skill)
 	if(sd) {
-		switch(skill_num){
+		switch(skill_id){
 		case SA_CASTCANCEL:
-			if(ud->skillid != skill_num){
-				sd->skillid_old = ud->skillid;
-				sd->skilllv_old = ud->skilllv;
+			if(ud->skill_id != skill_id){
+				sd->skill_id_old = ud->skill_id;
+				sd->skill_lv_old = ud->skill_lv;
 			}
 			break;
 		case BD_ENCORE:
 			//Prevent using the dance skill if you no longer have the skill in your tree.
-			if(!sd->skillid_dance || pc_checkskill(sd,sd->skillid_dance)<=0){
-				clif_skill_fail(sd,skill_num,USESKILL_FAIL_LEVEL,0);
+			if(!sd->skill_id_dance || pc_checkskill(sd,sd->skill_id_dance)<=0){
+				clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 				return 0;
 			}
-			sd->skillid_old = skill_num;
+			sd->skill_id_old = skill_id;
 			break;
 		case BD_LULLABY:
 		case BD_RICHMANKIM:
@@ -1136,31 +1136,31 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 		case BD_INTOABYSS:
 		case BD_SIEGFRIED:
 		case CG_MOONLIT:
-			if (skill_check_pc_partner(sd, skill_num, &skill_lv, 1, 0) < 1)
+			if (skill_check_pc_partner(sd, skill_id, &skill_lv, 1, 0) < 1)
 			{
-				clif_skill_fail(sd,skill_num,USESKILL_FAIL_LEVEL,0);
+				clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 				return 0;
 			}
 			break;
 		case WL_WHITEIMPRISON:
 			if( battle_check_target(src,target,BCT_SELF|BCT_ENEMY) < 0 ) {
-				clif_skill_fail(sd,skill_num,USESKILL_FAIL_TOTARGET,0);
+				clif_skill_fail(sd,skill_id,USESKILL_FAIL_TOTARGET,0);
 				return 0;
 			}
 			break;
 		case MG_FIREBOLT:
 		case MG_LIGHTNINGBOLT:
 		case MG_COLDBOLT:
-			sd->skillid_old = skill_num;
-			sd->skilllv_old = skill_lv;
+			sd->skill_id_old = skill_id;
+			sd->skill_lv_old = skill_lv;
 			break;
 		}
-		if (!skill_check_condition_castbegin(sd, skill_num, skill_lv))
+		if (!skill_check_condition_castbegin(sd, skill_id, skill_lv))
 			return 0;
 	}
 
 	if( src->type == BL_MOB )
-		switch( skill_num )
+		switch( skill_id )
 		{
 			case NPC_SUMMONSLAVE:
 			case NPC_SUMMONMONSTER:
@@ -1172,13 +1172,13 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	//Check range when not using skill on yourself or is a combo-skill during attack
 	//(these are supposed to always have the same range as your attack)
 	if( src->id != target_id && (!temp || ud->attacktimer == INVALID_TIMER) ) {
-		if( skill_get_state(ud->skillid) == ST_MOVE_ENABLE ) {
-			if( !unit_can_reach_bl(src, target, skill_get_range2(src, skill_num,skill_lv) + 1, 1, NULL, NULL) )
+		if( skill_get_state(ud->skill_id) == ST_MOVE_ENABLE ) {
+			if( !unit_can_reach_bl(src, target, skill_get_range2(src, skill_id,skill_lv) + 1, 1, NULL, NULL) )
 				return 0; // Walk-path check failed.
-		} else if( src->type == BL_MER && skill_num == MA_REMOVETRAP ) {
-			if( !battle_check_range(battle_get_master(src), target, skill_get_range2(src, skill_num, skill_lv) + 1) )
+		} else if( src->type == BL_MER && skill_id == MA_REMOVETRAP ) {
+			if( !battle_check_range(battle_get_master(src), target, skill_get_range2(src, skill_id, skill_lv) + 1) )
 				return 0; // Aegis calc remove trap based on Master position, ignoring mercenary O.O
-		} else if( !battle_check_range(src, target, skill_get_range2(src, skill_num,skill_lv) + (skill_num == RG_CLOSECONFINE?0:2)) ) {
+		} else if( !battle_check_range(src, target, skill_get_range2(src, skill_id,skill_lv) + (skill_id == RG_CLOSECONFINE?0:2)) ) {
 			return 0; // Arrow-path check failed.
 		}
 	}
@@ -1193,7 +1193,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	//temp: Used to signal force cast now.
 	temp = 0;
 
-	switch(skill_num){
+	switch(skill_id){
 	case ALL_RESURRECTION:
 		if(battle_check_undead(tstatus->race,tstatus->def_ele)) {
 			temp = 1;
@@ -1260,9 +1260,9 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	case EL_TIDAL_WEAPON:
 		if( src->type == BL_ELEM ){
 			sd = BL_CAST(BL_PC, battle_get_master(src));
-			if( sd && sd->skillid_old == SO_EL_ACTION ){
+			if( sd && sd->skill_id_old == SO_EL_ACTION ){
 				casttime = -1;
-				sd->skillid_old = 0;
+				sd->skill_id_old = 0;
 			}
 		}
 		break;
@@ -1270,10 +1270,10 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 
 	// moved here to prevent Suffragium from ending if skill fails
 #ifndef RENEWAL_CAST
-	if (!(skill_get_castnodex(skill_num, skill_lv)&2))
+	if (!(skill_get_castnodex(skill_id, skill_lv)&2))
 		casttime = skill_castfix_sc(src, casttime);
 #else
-	casttime = skill_vfcastfix(src, casttime, skill_num, skill_lv);
+	casttime = skill_vfcastfix(src, casttime, skill_id, skill_lv);
 #endif
 
 	if (src->type == BL_NPC) { // NPC-objects do not have cast time
@@ -1283,7 +1283,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	if(!ud->state.running) //need TK_RUN or WUGDASH handler to be done before that, see bugreport:6026
 		unit_stop_walking(src,1);// eventhough this is not how official works but this will do the trick. bugreport:6829
 	// in official this is triggered even if no cast time.
-	clif_skillcasting(src, src->id, target_id, 0,0, skill_num, skill_get_ele(skill_num, skill_lv), casttime);
+	clif_skillcasting(src, src->id, target_id, 0,0, skill_id, skill_get_ele(skill_id, skill_lv), casttime);
 	if( casttime > 0 || temp )
 	{
 		if (sd && target->type == BL_MOB)
@@ -1318,11 +1318,11 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	if( casttime <= 0 )
 		ud->state.skillcastcancel = 0;
 
-	if( !sd || sd->skillitem != skill_num || skill_get_cast(skill_num,skill_lv) )
+	if( !sd || sd->skillitem != skill_id || skill_get_cast(skill_id,skill_lv) )
 		ud->canact_tick = tick + casttime + 100;
 	if( sd )
 	{
-		switch( skill_num )
+		switch( skill_id )
 		{
 		case CG_ARROWVULCAN:
 			sd->canequip_tick = tick + casttime;
@@ -1332,17 +1332,17 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	ud->skilltarget  = target_id;
 	ud->skillx       = 0;
 	ud->skilly       = 0;
-	ud->skillid      = skill_num;
-	ud->skilllv      = skill_lv;
+	ud->skill_id      = skill_id;
+	ud->skill_lv      = skill_lv;
 
 	if( sc ) {
 		/**
 		 * why the if else chain: these 3 status do not stack, so its efficient that way.
 		 **/
- 		if( sc->data[SC_CLOAKING] && !(sc->data[SC_CLOAKING]->val4&4) && skill_num != AS_CLOAKING ) {
+ 		if( sc->data[SC_CLOAKING] && !(sc->data[SC_CLOAKING]->val4&4) && skill_id != AS_CLOAKING ) {
 			status_change_end(src, SC_CLOAKING, INVALID_TIMER);
 			if (!src->prev) return 0; //Warped away!
-		} else if( sc->data[SC_CLOAKINGEXCEED] && !(sc->data[SC_CLOAKINGEXCEED]->val4&4) && skill_num != GC_CLOAKINGEXCEED ) {
+		} else if( sc->data[SC_CLOAKINGEXCEED] && !(sc->data[SC_CLOAKINGEXCEED]->val4&4) && skill_id != GC_CLOAKINGEXCEED ) {
 			status_change_end(src,SC_CLOAKINGEXCEED, INVALID_TIMER);
 			if (!src->prev) return 0;
 		}
@@ -1352,7 +1352,7 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	if( casttime > 0 )
 	{
 		ud->skilltimer = add_timer( tick+casttime, skill_castend_id, src->id, 0 );
-		if( sd && (pc_checkskill(sd,SA_FREECAST) > 0 || skill_num == LG_EXEEDBREAK) )
+		if( sd && (pc_checkskill(sd,SA_FREECAST) > 0 || skill_id == LG_EXEEDBREAK) )
 			status_calc_bl(&sd->bl, SCB_SPEED);
 	}
 	else
@@ -1361,18 +1361,18 @@ int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, sh
 	return 1;
 }
 
-int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, short skill_num, short skill_lv)
+int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv)
 {
-	if(skill_num < 0)
+	if(skill_id < 0)
 		return 0;
 	return unit_skilluse_pos2(
-		src, skill_x, skill_y, skill_num, skill_lv,
-		skill_castfix(src, skill_num, skill_lv),
-		skill_get_castcancel(skill_num)
+		src, skill_x, skill_y, skill_id, skill_lv,
+		skill_castfix(src, skill_id, skill_lv),
+		skill_get_castcancel(skill_id)
 	);
 }
 
-int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, short skill_num, short skill_lv, int casttime, int castcancel)
+int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel)
 {
 	struct map_session_data *sd = NULL;
 	struct unit_data        *ud = NULL;
@@ -1398,24 +1398,24 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, sh
 
 	if( sd )
 	{
-		if( skillnotok(skill_num, sd) || !skill_check_condition_castbegin(sd, skill_num, skill_lv) )
+		if( skillnotok(skill_id, sd) || !skill_check_condition_castbegin(sd, skill_id, skill_lv) )
 			return 0;
 		/**
 		 * "WHY IS IT HEREE": pneuma cannot be cancelled past this point, the client displays the animation even,
 		 * if we cancel it from nodamage_id, so it has to be here for it to not display the animation.
 		 **/
-		if( skill_num == AL_PNEUMA && map_getcell(src->m, skill_x, skill_y, CELL_CHKLANDPROTECTOR) ) {
-			clif_skill_fail(sd,skill_num,USESKILL_FAIL_LEVEL,0);
+		if( skill_id == AL_PNEUMA && map_getcell(src->m, skill_x, skill_y, CELL_CHKLANDPROTECTOR) ) {
+			clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 			return 0;
 		}
 	}
 
-	if (!status_check_skilluse(src, NULL, skill_num, 0))
+	if (!status_check_skilluse(src, NULL, skill_id, 0))
 		return 0;
 
 	if( map_getcell(src->m, skill_x, skill_y, CELL_CHKWALL) )
 	{// can't cast ground targeted spells on wall cells
-		if (sd) clif_skill_fail(sd,skill_num,USESKILL_FAIL_LEVEL,0);
+		if (sd) clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
 		return 0;
 	}
 
@@ -1425,22 +1425,22 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, sh
 	bl.x = skill_x;
 	bl.y = skill_y;
 
-	if( skill_get_state(ud->skillid) == ST_MOVE_ENABLE )
+	if( skill_get_state(ud->skill_id) == ST_MOVE_ENABLE )
 	{
-		if( !unit_can_reach_bl(src, &bl, skill_get_range2(src, skill_num,skill_lv) + 1, 1, NULL, NULL) )
+		if( !unit_can_reach_bl(src, &bl, skill_get_range2(src, skill_id,skill_lv) + 1, 1, NULL, NULL) )
 			return 0; //Walk-path check failed.
 	}
-	else if( !battle_check_range(src, &bl, skill_get_range2(src, skill_num,skill_lv) + 1) )
+	else if( !battle_check_range(src, &bl, skill_get_range2(src, skill_id,skill_lv) + 1) )
 		return 0; //Arrow-path check failed.
 
 	unit_stop_attack(src);
 
 	// moved here to prevent Suffragium from ending if skill fails
 #ifndef RENEWAL_CAST
-	if (!(skill_get_castnodex(skill_num, skill_lv)&2))
+	if (!(skill_get_castnodex(skill_id, skill_lv)&2))
 		casttime = skill_castfix_sc(src, casttime);
 #else
-	casttime = skill_vfcastfix(src, casttime, skill_num, skill_lv );
+	casttime = skill_vfcastfix(src, casttime, skill_id, skill_lv );
 #endif
 
 	if (src->type == BL_NPC) { // NPC-objects do not have cast time
@@ -1448,18 +1448,18 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, sh
 	}
 
 	ud->state.skillcastcancel = castcancel&&casttime>0?1:0;
-	if( !sd || sd->skillitem != skill_num || skill_get_cast(skill_num,skill_lv) )
+	if( !sd || sd->skillitem != skill_id || skill_get_cast(skill_id,skill_lv) )
 		ud->canact_tick  = tick + casttime + 100;
 //	if( sd )
 //	{
-//		switch( skill_num )
+//		switch( skill_id )
 //		{
 //		case ????:
 //			sd->canequip_tick = tick + casttime;
 //		}
 //	}
-	ud->skillid      = skill_num;
-	ud->skilllv      = skill_lv;
+	ud->skill_id      = skill_id;
+	ud->skill_lv      = skill_lv;
 	ud->skillx       = skill_x;
 	ud->skilly       = skill_y;
 	ud->skilltarget  = 0;
@@ -1479,11 +1479,11 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, sh
 
 	unit_stop_walking(src,1);
 	// in official this is triggered even if no cast time.
-	clif_skillcasting(src, src->id, 0, skill_x, skill_y, skill_num, skill_get_ele(skill_num, skill_lv), casttime);
+	clif_skillcasting(src, src->id, 0, skill_x, skill_y, skill_id, skill_get_ele(skill_id, skill_lv), casttime);
 	if( casttime > 0 )
 	{
 		ud->skilltimer = add_timer( tick+casttime, skill_castend_pos, src->id, 0 );
-		if( (sd && pc_checkskill(sd,SA_FREECAST) > 0) || skill_num == LG_EXEEDBREAK)
+		if( (sd && pc_checkskill(sd,SA_FREECAST) > 0) || skill_id == LG_EXEEDBREAK)
 			status_calc_bl(&sd->bl, SCB_SPEED);
 	}
 	else
@@ -1674,7 +1674,7 @@ bool unit_can_reach_bl(struct block_list *bl,struct block_list *tbl, int range,
 /*==========================================
  * Calculates position of Pet/Mercenary/Homunculus/Elemental
  *------------------------------------------*/
-int	unit_calc_pos(struct block_list *bl, int tx, int ty, int dir)
+int	unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir)
 {
 	int dx, dy, x, y, i, k;
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -1900,16 +1900,16 @@ int unit_skillcastcancel(struct block_list *bl,int type)
 	ud->canact_tick = tick;
 
 	if(type&1 && sd)
-		skill = sd->skillid_old;
+		skill = sd->skill_id_old;
 	else
-		skill = ud->skillid;
+		skill = ud->skill_id;
 
 	if (skill_get_inf(skill) & INF_GROUND_SKILL)
 		ret=delete_timer( ud->skilltimer, skill_castend_pos );
 	else
 		ret=delete_timer( ud->skilltimer, skill_castend_id );
 	if(ret<0)
-		ShowError("delete timer error : skillid : %d\n",ret);
+		ShowError("delete timer error : skill_id : %d\n",ret);
 
 	ud->skilltimer = INVALID_TIMER;
 
@@ -1926,7 +1926,7 @@ int unit_skillcastcancel(struct block_list *bl,int type)
 		}
 	}
 
-	if(bl->type==BL_MOB) ((TBL_MOB*)bl)->skillidx  = -1;
+	if(bl->type==BL_MOB) ((TBL_MOB*)bl)->skill_idx  = -1;
 
 	clif_skillcastcancel(bl);
 	return 1;

src/map/unit.h

@@ -23,7 +23,7 @@ struct unit_data {
 	short attacktarget_lv;
 	short to_x,to_y;
 	short skillx,skilly;
-	short skillid,skilllv;
+	uint16 skill_id,skill_lv;
 	int   skilltarget;
 	int   skilltimer;
 	int   target;
@@ -75,10 +75,10 @@ struct view_data {
 int unit_walktoxy( struct block_list *bl, short x, short y, int easy);
 int unit_walktobl( struct block_list *bl, struct block_list *target, int range, int easy);
 int unit_run(struct block_list *bl);
-int unit_calc_pos(struct block_list *bl, int tx, int ty, int dir);
+int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir);
 
 // 歩行停止
-// typeは以下の組み合わせ : 
+// typeは以下の組み合わせ :
 //     1: 位置情報の送信( この関数の後に位置情報を送信する場合は不要 )
 //     2: ダメージディレイ有り
 //     4: 不明(MOBのみ？)
@@ -105,12 +105,12 @@ int unit_attack(struct block_list *src,int target_id,int continuous);
 int unit_cancel_combo(struct block_list *bl);
 
 // スキル使用
-int unit_skilluse_id(struct block_list *src, int target_id, short skill_num, short skill_lv);
-int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, short skill_num, short skill_lv);
+int unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv);
+int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv);
 
 // スキル使用( 補正済みキャスト時間、キャンセル不可設定付き )
-int unit_skilluse_id2(struct block_list *src, int target_id, short skill_num, short skill_lv, int casttime, int castcancel);
-int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, short skill_num, short skill_lv, int casttime, int castcancel);
+int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel);
+int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel);
 
 // 詠唱キャンセル
 int unit_skillcastcancel(struct block_list *bl,int type);