diff --git a/src/map/clif.c b/src/map/clif.c
index 3e8d5206fc..d45c05ffa0 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -1931,6 +1931,7 @@ void clif_scriptclear(struct map_session_data *sd, int npcid)
 	struct s_packet_db* info;
 	int16 len;
 	int cmd = 0;
+	int fd;
 
 	nullpo_retv(sd);
 
@@ -1938,6 +1939,7 @@ void clif_scriptclear(struct map_session_data *sd, int npcid)
 	if(!cmd) cmd = 0x8d6; //default
 	info = &packet_db[sd->packet_ver][cmd];
 	len = info->len;
+	fd = sd->fd;
 
 	WFIFOHEAD(fd, len);
 	WFIFOW(fd,0)=0x8d6;
diff --git a/src/map/status.c b/src/map/status.c
index 809cbdf67c..97fb0dd008 100644
--- a/src/map/status.c
+++ b/src/map/status.c
@@ -1412,7 +1412,9 @@ int status_damage(struct block_list *src,struct block_list *target,int64 dhp, in
 	}
 
 	// Always run NPC scripts for players last
-	if(target->type == BL_PC) {
+	//FIXME those ain't always run if a player die if he was resurect meanwhile
+	//cf SC_REBIRTH, SC_LIGHT_OF_REGENE, SC_KAIZEL, pc_dead...
+	if(target->type == BL_PC) { 
 		TBL_PC *sd = BL_CAST(BL_PC,target);
 		if( sd->bg_id ) {
 			struct battleground_data *bg;
@@ -1431,7 +1433,7 @@ int status_damage(struct block_list *src,struct block_list *target,int64 dhp, in
 * @param bl: Object to heal [PC|MOB|HOM|MER|ELEM]
 * @param hhp: How much HP to heal
 * @param hsp: How much SP to heal
-* @param flag:	Whether it's Forced(&1) or gives HP/SP(&2) heal effect
+* @param flag:	Whether it's Forced(&1) or gives HP/SP(&2) heal effect \n
 *		Forced healing overrides heal impedement statuses (Berserk)
 * @return hp+sp
 **/
@@ -1512,7 +1514,8 @@ int status_heal(struct block_list *bl,int64 hhp,int64 hsp, int flag)
 * @param target: Object to modify HP/SP
 * @param hp_rate: Percentage of HP to modify
 * @param sp_rate: Percentage of SP to modify
-* @param flag:	0: Heal target
+* @param flag: \n
+*		0: Heal target \n 
 *		2: Target must not die from subtraction
 * @return hp+sp through status_heal()
 **/
diff --git a/src/map/storage.c b/src/map/storage.c
index c177195fd1..c64a3312c5 100644
--- a/src/map/storage.c
+++ b/src/map/storage.c
@@ -24,11 +24,15 @@
 #include <string.h>
 
 
-static DBMap* guild_storage_db; // int guild_id -> struct guild_storage*
+static DBMap* guild_storage_db; ///Databases of guild_storage : int guild_id -> struct guild_storage*
 
-/*==========================================
- * Sort items in the warehouse
- *------------------------------------------*/
+/**
+ * Storage item comparator (for qsort)
+ * sort by itemid and amount
+ * @param _i1 : item a
+ * @param _i2 : item b
+ * @return i1<=>i2
+ */
 static int storage_comp_item(const void *_i1, const void *_i2)
 {
 	struct item *i1 = (struct item *)_i1;
@@ -43,7 +47,12 @@ static int storage_comp_item(const void *_i1, const void *_i2)
 	return i1->nameid - i2->nameid;
 }
 
-//Sort item by storage_comp_item (nameid)
+/**
+ * Sort item by storage_comp_item (nameid)
+ * used when we open up our storage or guild_storage
+ * @param items : list of items to sort
+ * @param size : number of item in list
+ */
 static void storage_sortitem(struct item* items, unsigned int size)
 {
 	nullpo_retv(items);
@@ -54,22 +63,32 @@ static void storage_sortitem(struct item* items, unsigned int size)
 	}
 }
 
-/*==========================================
- * Init/Terminate
- *------------------------------------------*/
-int do_init_storage(void) // Called from map.c::do_init()
+/**
+ * Initiate storage module
+ * Called from map.c::do_init()
+ * @return 1
+ */
+int do_init_storage(void) // 
 {
 	guild_storage_db=idb_alloc(DB_OPT_RELEASE_DATA);
 	return 1;
 }
-void do_final_storage(void) // by [MC Cameri]
+
+/**
+ * Destroy storage module
+ * @author : [MC Cameri]
+ * Called from map.c::do_final()
+ */
+void do_final_storage(void)
 {
 	guild_storage_db->destroy(guild_storage_db,NULL);
 }
 
 /**
- * Parses storage and saves 'dirty' ones upon reconnect. [Skotlex]
+ * Parses storage and saves 'dirty' ones upon reconnect.
+ * @author [Skotlex]
  * @see DBApply
+ * @return 0
  */
 static int storage_reconnect_sub(DBKey key, DBData *data, va_list ap)
 {
@@ -80,17 +99,20 @@ static int storage_reconnect_sub(DBKey key, DBData *data, va_list ap)
 	return 0;
 }
 
-//Function to be invoked upon server reconnection to char. To save all 'dirty' storages [Skotlex]
+/**
+ * Function to be invoked upon server reconnection to char. To save all 'dirty' storages
+ * @author [Skotlex]
+ */
 void do_reconnect_storage(void)
 {
 	guild_storage_db->foreach(guild_storage_db, storage_reconnect_sub);
 }
 
-/*==========================================
- * Opens a storage. Returns:
- * 0 - success
- * 1 - fail
- *------------------------------------------*/
+/**
+ * Player attempt tp open his storage.
+ * @param sd : player
+ * @return  0:success, 1:fail
+ */
 int storage_storageopen(struct map_session_data *sd)
 {
 	nullpo_ret(sd);
@@ -111,8 +133,11 @@ int storage_storageopen(struct map_session_data *sd)
 	return 0;
 }
 
-/* helper function
- * checking if 2 item structure are identique
+/**
+ * check if 2 item a and b have same values
+ * @param a : item 1
+ * @param b : item 2
+ * @return 1:same, 0:are different
  */
 int compare_item(struct item *a, struct item *b)
 {
@@ -130,9 +155,13 @@ int compare_item(struct item *a, struct item *b)
 	return 0;
 }
 
-/*==========================================
- * Internal add-item function.
- *------------------------------------------*/
+/**
+ * Make a player add an item to his storage
+ * @param sd : player
+ * @param item_data : item to add
+ * @param amount : quantity of items
+ * @return 0:success, 1:failed
+ */
 static int storage_additem(struct map_session_data* sd, struct item* item_data, int amount)
 {
 	struct storage_data* stor = &sd->status.storage;
@@ -190,9 +219,13 @@ static int storage_additem(struct map_session_data* sd, struct item* item_data,
 	return 0;
 }
 
-/*==========================================
- * Internal del-item function
- *------------------------------------------*/
+/**
+ * Make a player delete an item from his storage
+ * @param sd : player
+ * @param n : idx on storage to remove the item from
+ * @param amount :number of item to remove
+ * @return 0:sucess, 1:fail
+ */
 int storage_delitem(struct map_session_data* sd, int n, int amount)
 {
 	if( sd->status.storage.items[n].nameid == 0 || sd->status.storage.items[n].amount < amount )
@@ -209,13 +242,13 @@ int storage_delitem(struct map_session_data* sd, int n, int amount)
 	return 0;
 }
 
-/*==========================================
+/**
  * Add an item to the storage from the inventory.
- * @index : inventory idx
- * return
- *	0 : fail
- *	1 : success
- *------------------------------------------*/
+ * @param sd : player
+ * @param index : inventory index to take the item from
+ * @param amount : number of item to take
+ * @return 0:fail, 1:success
+ */
 int storage_storageadd(struct map_session_data* sd, int index, int amount)
 {
 	nullpo_ret(sd);
@@ -242,13 +275,13 @@ int storage_storageadd(struct map_session_data* sd, int index, int amount)
 	return 1;
 }
 
-/*==========================================
+/**
  * Retrieve an item from the storage into inventory
- * @index : storage idx
- * return
- *	0 : fail
- *	1 : success
- *------------------------------------------*/
+ * @param sd : player
+ * @param index : storage index to take the item from
+ * @param amount : number of item to take
+ * @return 0:fail, 1:success
+ */
 int storage_storageget(struct map_session_data* sd, int index, int amount)
 {
 	int flag;
@@ -270,13 +303,13 @@ int storage_storageget(struct map_session_data* sd, int index, int amount)
 	return 1;
 }
 
-/*==========================================
+/**
  * Move an item from cart to storage.
- * @index : cart inventory index
- * return
- *	0 : fail
- *	1 : success
- *------------------------------------------*/
+ * @param sd : player
+ * @param index : cart index to take the item from
+ * @param amount : number of item to take
+ * @return 0:fail, 1:success
+ */
 int storage_storageaddfromcart(struct map_session_data* sd, int index, int amount)
 {
 	nullpo_ret(sd);
@@ -299,13 +332,13 @@ int storage_storageaddfromcart(struct map_session_data* sd, int index, int amoun
 	return 1;
 }
 
-/*==========================================
+/**
  * Get from Storage to the Cart inventory
- * @index : storage index
- * return
- *	0 : fail
- *	1 : success
- *------------------------------------------*/
+ * @param sd : player
+ * @param index : storage index to take the item from
+ * @param amount : number of item to take
+ * @return 0:fail, 1:success
+ */
 int storage_storagegettocart(struct map_session_data* sd, int index, int amount)
 {
 	short flag;
@@ -331,9 +364,11 @@ int storage_storagegettocart(struct map_session_data* sd, int index, int amount)
 }
 
 
-/*==========================================
- * Modified By Valaris to save upon closing [massdriller]
- *------------------------------------------*/
+/**
+ * Make player close his storage
+ * @author : [massdriller] / modified by [Valaris]
+ * @param sd : player
+ */
 void storage_storageclose(struct map_session_data* sd)
 {
 	nullpo_retv(sd);
@@ -346,9 +381,14 @@ void storage_storageclose(struct map_session_data* sd)
 	sd->state.storage_flag = 0;
 }
 
-/*==========================================
- * When quitting the game.
- *------------------------------------------*/
+/**
+ * Force closing the storage for player without displaying result
+ * (exemple when quitting the game)
+ * @param sd : player to close storage
+ * @param flag : \n
+ *  1: Character is quitting \n
+ *	2(x): Character is changing map-servers 
+ */
 void storage_storage_quit(struct map_session_data* sd, int flag)
 {
 	nullpo_retv(sd);
@@ -360,7 +400,11 @@ void storage_storage_quit(struct map_session_data* sd, int flag)
 }
 
 /**
+ * Create a guild_storage stucture and add it into the db
  * @see DBCreateData
+ * @param key
+ * @param args
+ * @return 
  */
 static DBData create_guildstorage(DBKey key, va_list args)
 {
@@ -370,6 +414,12 @@ static DBData create_guildstorage(DBKey key, va_list args)
 	return db_ptr2data(gs);
 }
 
+/**
+ * Retrieve the guild_storage of a guild
+ * will create a new storage if none found for the guild
+ * @param guild_id : id of the guild
+ * @return guild_storage
+ */
 struct guild_storage *guild2storage(int guild_id)
 {
 	struct guild_storage *gs = NULL;
@@ -378,25 +428,33 @@ struct guild_storage *guild2storage(int guild_id)
 	return gs;
 }
 
-//For just locating a storage without creating one. [Skotlex]
+/**
+ * See if the guild_storage exist in db and fetch it if it,s the case
+ * @author : [Skotlex]
+ * @param guild_id : guild_id to search the storage
+ * @return guild_storage or NULL
+ */
 struct guild_storage *guild2storage2(int guild_id)
 {
 	return (struct guild_storage*)idb_get(guild_storage_db,guild_id);
 }
 
+/**
+ * Delete a guild_storage and remove it from db
+ * @param guild_id : guild to remove the storage from
+ * @return 0
+ */
 int guild_storage_delete(int guild_id)
 {
 	idb_remove(guild_storage_db,guild_id);
 	return 0;
 }
 
-/*==========================================
-* Attempt to open guild storage for sd
-* return
-* 	0 : success (open or req to create a new one)
-* 	1 : fail
-*	2 : no guild for sd
- *------------------------------------------*/
+/**
+ * Attempt to open guild storage for player
+ * @param sd : player
+ * @return * 	0 : success, 1 : fail, 2 : no guild found
+ */
 int storage_guild_storageopen(struct map_session_data* sd)
 {
 	struct guild_storage *gstor;
@@ -432,12 +490,14 @@ int storage_guild_storageopen(struct map_session_data* sd)
 	return 0;
 }
 
-/*==========================================
-* Attempt to add an item in guild storage, then refresh it
-* return
-* 	0 : success
-* 	1 : fail
- *------------------------------------------*/
+/**
+ * Attempt to add an item in guild storage, then refresh it
+ * @param sd : player attempting to open the guild_storage
+ * @param stor : guild_storage
+ * @param item_data : item to add
+ * @param amount : number of item to add
+ * @return 0 : success, 1 : fail
+ */
 int guild_storage_additem(struct map_session_data* sd, struct guild_storage* stor, struct item* item_data, int amount)
 {
 	struct item_data *data;
@@ -495,12 +555,14 @@ int guild_storage_additem(struct map_session_data* sd, struct guild_storage* sto
 	return 0;
 }
 
-/*==========================================
-* Attempt to delete an item in guild storage, then refresh it
-* return
-* 	0 : success
-* 	1 : fail
- *------------------------------------------*/
+/**
+ * Attempt to delete an item in guild storage, then refresh it
+ * @param sd : player
+ * @param stor : guild_storage
+ * @param n : index of item in guild storage
+ * @param amount : number of item to delete
+ * @return 0 : success, 1 : fail
+ */
 int guild_storage_delitem(struct map_session_data* sd, struct guild_storage* stor, int n, int amount)
 {
 	nullpo_retr(1, sd);
@@ -520,13 +582,12 @@ int guild_storage_delitem(struct map_session_data* sd, struct guild_storage* sto
 	return 0;
 }
 
-/*==========================================
-* Attempt to add an item in guild storage from inventory, then refresh it
-* @index : inventory idx
-* return
-* 	0 : fail
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * Attempt to add an item in guild storage from inventory, then refresh it
+ * @param sd : player
+ * @param amount : number of item to delete
+ * @return 1:success, 0:fail
+ */
 int storage_guild_storageadd(struct map_session_data* sd, int index, int amount)
 {
 	struct guild_storage *stor;
@@ -561,13 +622,13 @@ int storage_guild_storageadd(struct map_session_data* sd, int index, int amount)
 	return 1;
 }
 
-/*==========================================
-* Attempt to retrieve an item from guild storage to inventory, then refresh it
-* @index : storage idx
-* return
-* 	0 : fail
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * Attempt to retrieve an item from guild storage to inventory, then refresh it
+ * @param sd : player
+ * @param index : index of item in storage
+ * @param amount : number of item to get
+ * @return 1:success, 0:fail
+ */
 int storage_guild_storageget(struct map_session_data* sd, int index, int amount)
 {
 	struct guild_storage *stor;
@@ -595,20 +656,22 @@ int storage_guild_storageget(struct map_session_data* sd, int index, int amount)
 
 	if((flag = pc_additem(sd,&stor->items[index],amount,LOG_TYPE_GSTORAGE)) == 0)
 		guild_storage_delitem(sd,stor,index,amount);
-	else //inform fail
+	else {//inform fail
 		clif_additem(sd,0,0,flag);
+		return 0;
+	}
 //	log_fromstorage(sd, index, 1);
 
-	return 0;
+	return 1;
 }
 
-/*==========================================
-* Attempt to add an item in guild storage from cart, then refresh it
-* @index : cart inventory idx
-* return
-* 	0 : fail
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * Attempt to add an item in guild storage from cart, then refresh it
+ * @param sd : player
+ * @param index : index of item in cart
+ * @param amount : number of item to transfer
+ * @return 1:fail, 0:success
+ */
 int storage_guild_storageaddfromcart(struct map_session_data* sd, int index, int amount)
 {
 	struct guild_storage *stor;
@@ -634,13 +697,13 @@ int storage_guild_storageaddfromcart(struct map_session_data* sd, int index, int
 	return 1;
 }
 
-/*==========================================
-* Attempt to retrieve an item from guild storage to cart, then refresh it
-* @index : storage idx
-* return
-* 	0 : fail
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * Attempt to retrieve an item from guild storage to cart, then refresh it
+ * @param sd : player
+ * @param index : index of item in storage
+ * @param amount : number of item to transfert
+ * @return 1:fail, 0:success
+ */
 int storage_guild_storagegettocart(struct map_session_data* sd, int index, int amount)
 {
 	short flag;
@@ -666,17 +729,19 @@ int storage_guild_storagegettocart(struct map_session_data* sd, int index, int a
 	else {
 		clif_dropitem(sd,index,0);
 		clif_cart_additem_ack(sd,(flag==1)?ADDITEM_TO_CART_FAIL_WEIGHT:ADDITEM_TO_CART_FAIL_COUNT);
+		return 0;
 	}
 
 	return 1;
 }
 
-/*==========================================
-* Request to save guild storage
-* return
-* 	0 : fail (no storage)
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * Request to save guild storage
+ * @param account_id : account requesting the save
+ * @param guild_id : guild to take the guild_storage
+ * @param flag : ?
+ * @return 0 : fail (no storage), 1 : success (requested)
+ */
 int storage_guild_storagesave(int account_id, int guild_id, int flag)
 {
 	struct guild_storage *stor = guild2storage2(guild_id);
@@ -692,12 +757,11 @@ int storage_guild_storagesave(int account_id, int guild_id, int flag)
 	return 0;
 }
 
-/*==========================================
-* ACK save of guild storage
-* return
-* 	0 : fail (no storage)
-* 	1 : succes
- *------------------------------------------*/
+/**
+ * ACK save of guild storage
+ * @param guild_id : guild to use the storage
+ * @return 0 : fail (no storage), 1 : succes
+ */
 int storage_guild_storagesaved(int guild_id)
 {
 	struct guild_storage *stor;
@@ -712,7 +776,11 @@ int storage_guild_storagesaved(int guild_id)
 	return 0;
 }
 
-//Close storage for sd and save it
+/**
+ * Close storage for player then save it
+ * @param sd : player
+ * @return 0
+ */
 int storage_guild_storageclose(struct map_session_data* sd)
 {
 	struct guild_storage *stor;
@@ -734,6 +802,12 @@ int storage_guild_storageclose(struct map_session_data* sd)
 	return 0;
 }
 
+/**
+ * Close storage for player then save it
+ * @param sd
+ * @param flag
+ * @return 
+ */
 int storage_guild_storage_quit(struct map_session_data* sd, int flag)
 {
 	struct guild_storage *stor;
diff --git a/src/map/trade.c b/src/map/trade.c
index 3f798d4ee9..12cba927d4 100644
--- a/src/map/trade.c
+++ b/src/map/trade.c
@@ -20,13 +20,13 @@
 #include <stdio.h>
 #include <string.h>
 
+#define TRADE_DISTANCE 2 ///Max distance from traders to enable a trade to take place.
 
-//Max distance from traders to enable a trade to take place.
-#define TRADE_DISTANCE 2
-
-/*==========================================
- * Initiates a trade request.
- *------------------------------------------*/
+/**
+ * Player initiates a trade request.
+ * @param sd : player requesting the trade
+ * @param target_sd : player requested
+ */
 void trade_traderequest(struct map_session_data *sd, struct map_session_data *target_sd)
 {
 	nullpo_retv(sd);
@@ -88,17 +88,19 @@ void trade_traderequest(struct map_session_data *sd, struct map_session_data *ta
 	clif_traderequest(target_sd, sd->status.name);
 }
 
-/*==========================================
+
+/**
  * Reply to a trade-request.
- * Type values:
- * 0: Char is too far
- * 1: Character does not exist
- * 2: Trade failed
- * 3: Accept
- * 4: Cancel
- * Weird enough, the client should only send 3/4
+ * @param sd : player receiving the trade request answer
+ * @param type : answer code \n
+ *  0: Char is too far \n
+ *  1: Character does not exist \n
+ *  2: Trade failed \n
+ *  3: Accept \n
+ *  4: Cancel \n
+ * Weird enough, the client should only send 3/4 \n
  * and the server is the one that can reply 0~2
- *------------------------------------------*/
+ */
 void trade_tradeack(struct map_session_data *sd, int type)
 {
 	struct map_session_data *tsd;
@@ -165,11 +167,14 @@ void trade_tradeack(struct map_session_data *sd, int type)
 	clif_tradestart(sd, type);
 }
 
-/*==========================================
+/**
  * Check here hacker for duplicate item in trade
  * normal client refuse to have 2 same types of item (except equipment) in same trade window
  * normal client authorise only no equiped item and only from inventory
- *------------------------------------------*/
+ * This function could end player connection if too much hack is detected
+ * @param sd : player to check
+ * @return -1:zeny hack, 0:all fine, 1:item hack
+ */
 int impossible_trade_check(struct map_session_data *sd)
 {
 	struct item inventory[MAX_INVENTORY];
@@ -229,9 +234,12 @@ int impossible_trade_check(struct map_session_data *sd)
 	return 0;
 }
 
-/*==========================================
+/**
  * Checks if trade is possible (against zeny limits, inventory limits, etc)
- *------------------------------------------*/
+ * @param sd : player 1 trading
+ * @param tsd : player 2 trading
+ * @return 0:error, 1:success
+ */
 int trade_check(struct map_session_data *sd, struct map_session_data *tsd)
 {
 	struct item inventory[MAX_INVENTORY];
@@ -316,9 +324,12 @@ int trade_check(struct map_session_data *sd, struct map_session_data *tsd)
 	return 1;
 }
 
-/*==========================================
+/**
  * Adds an item/qty to the trade window
- *------------------------------------------*/
+ * @param sd : Player requesting to add stuff to the trade
+ * @param index : index of item in inventory
+ * @param amount : amount of item to add from index
+ */
 void trade_tradeadditem(struct map_session_data *sd, short index, short amount)
 {
 	struct map_session_data *target_sd;
@@ -409,9 +420,13 @@ void trade_tradeadditem(struct map_session_data *sd, short index, short amount)
 	clif_tradeadditem(sd, target_sd, index+2, amount);
 }
 
-/*==========================================
+/**
  * Adds the specified amount of zeny to the trade window
- *------------------------------------------*/
+ * This function will check if the player have enough money to do so
+ * And if the target player have enough space for that money
+ * @param sd : Player who's adding zeny
+ * @param amount : zeny amount
+ */
 void trade_tradeaddzeny(struct map_session_data* sd, int amount)
 {
 	struct map_session_data* target_sd;
@@ -436,9 +451,10 @@ void trade_tradeaddzeny(struct map_session_data* sd, int amount)
 	clif_tradeadditem(sd, target_sd, 0, amount);
 }
 
-/*==========================================
+/**
  * 'Ok' button on the trade window is pressed.
- *------------------------------------------*/
+ * @param sd : Player that pressed the button
+ */
 void trade_tradeok(struct map_session_data *sd)
 {
 	struct map_session_data *target_sd;
@@ -456,9 +472,10 @@ void trade_tradeok(struct map_session_data *sd)
 	clif_tradedeal_lock(target_sd, 1);
 }
 
-/*==========================================
+/**
  * 'Cancel' is pressed. (or trade was force-cancelled by the code)
- *------------------------------------------*/
+ * @param sd : Player that pressed the button
+ */
 void trade_tradecancel(struct map_session_data *sd)
 {
 	struct map_session_data *target_sd;
@@ -515,9 +532,11 @@ void trade_tradecancel(struct map_session_data *sd)
 	clif_tradecancelled(target_sd);
 }
 
-/*==========================================
+/**
+ * Execute the trade
  * lock sd and tsd trade data, execute the trade, clear, then save players
- *------------------------------------------*/
+ * @param sd : Player that has click on trade button
+ */
 void trade_tradecommit(struct map_session_data *sd)
 {
 	struct map_session_data *tsd;
diff --git a/src/map/unit.c b/src/map/unit.c
index 3015b916d3..6e31f79ea1 100644
--- a/src/map/unit.c
+++ b/src/map/unit.c
@@ -42,30 +42,43 @@
 #include <string.h>
 
 
-const short dirx[8]={0,-1,-1,-1,0,1,1,1};
-const short diry[8]={1,1,0,-1,-1,-1,0,1};
-
-struct unit_data* unit_bl2ud(struct block_list *bl)
-{
-	if( bl == NULL) return NULL;
-	if( bl->type == BL_PC)  return &((struct map_session_data*)bl)->ud;
-	if( bl->type == BL_MOB) return &((struct mob_data*)bl)->ud;
-	if( bl->type == BL_PET) return &((struct pet_data*)bl)->ud;
-	if( bl->type == BL_NPC) return &((struct npc_data*)bl)->ud;
-	if( bl->type == BL_HOM) return &((struct homun_data*)bl)->ud;
-	if( bl->type == BL_MER) return &((struct mercenary_data*)bl)->ud;
-	if( bl->type == BL_ELEM) return &((struct elemental_data*)bl)->ud;
-	return NULL;
-}
+// Directions values
+// 1 0 7
+// 2 . 6
+// 3 4 5
+const short dirx[8]={0,-1,-1,-1,0,1,1,1}; ///lookup to know where will move to x according dir
+const short diry[8]={1,1,0,-1,-1,-1,0,1}; ///lookup to know where will move to y according dir
 
+//early declaration
 static int unit_attack_timer(int tid, unsigned int tick, int id, intptr_t data);
 static int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data);
 
 /**
-* Tells a unit to walk to a specific coordinate
-* @param bl: Unit to walk [ALL]
-* @return 1: Success 0: Fail
-**/
+ * Get the unit_data related to the bl
+ * @param bl : Object to get the unit_data from \n
+ *	valid type are : BL_PC|BL_MOB|BL_PET|BL_NPC|BL_HOM|BL_MER|BL_ELEM
+ * @return unit_data of bl or NULL
+ */
+struct unit_data* unit_bl2ud(struct block_list *bl)
+{
+	if( bl == NULL) return NULL;
+	switch(bl->type){
+	case BL_PC: return &((struct map_session_data*)bl)->ud;
+	case BL_MOB: return &((struct mob_data*)bl)->ud;
+	case BL_PET: return &((struct pet_data*)bl)->ud;
+	case BL_NPC: return &((struct npc_data*)bl)->ud;
+	case BL_HOM: return &((struct homun_data*)bl)->ud;
+	case BL_MER: return &((struct mercenary_data*)bl)->ud;
+	case BL_ELEM: return &((struct elemental_data*)bl)->ud;
+	default : return NULL;
+	}
+}
+
+/**
+ * Tells a unit to walk to a specific coordinate
+ * @param bl: Unit to walk [ALL]
+ * @return 1: Success 0: Fail
+ */
 int unit_walktoxy_sub(struct block_list *bl)
 {
 	int i;
@@ -120,10 +133,10 @@ int unit_walktoxy_sub(struct block_list *bl)
 
 
 /**
-* Retrieve the direct master of a bl if one exists.
-* @param bl: char to get his master [HOM|ELEM|PET|MER]
-* @return map_session_data of master or NULL
-**/
+ * Retrieve the direct master of a bl if one exists.
+ * @param bl: char to get his master [HOM|ELEM|PET|MER]
+ * @return map_session_data of master or NULL
+ */
 TBL_PC* unit_get_master(struct block_list *bl)
 {
 	if(bl)
@@ -137,10 +150,10 @@ TBL_PC* unit_get_master(struct block_list *bl)
 }
 
 /**
-* Retrieve a unit's master's teleport timer
-* @param bl: char to get his master's teleport timer [HOM|ELEM|PET|MER]
-* @return timer or NULL
-**/
+ * Retrieve a unit's master's teleport timer
+ * @param bl: char to get his master's teleport timer [HOM|ELEM|PET|MER]
+ * @return timer or NULL
+ */
 int* unit_get_masterteleport_timer(struct block_list *bl)
 {
 	if(bl)
@@ -154,14 +167,14 @@ int* unit_get_masterteleport_timer(struct block_list *bl)
 }
 
 /**
-* Warps a unit to its master master has gone out of site (3 second default) \n
-* Can be any object with a master [MOB|PET|HOM|MER|ELEM]
-* @param tid: Timer
-* @param tick: tick (unused)
-* @param id: Unit to warp
-* @param data: Data transferred from timer call
-* @return 0
-**/
+ * Warps a unit to its master master has gone out of site (3 second default) \n
+ * Can be any object with a master [MOB|PET|HOM|MER|ELEM]
+ * @param tid: Timer
+ * @param tick: tick (unused)
+ * @param id: Unit to warp
+ * @param data: Data transferred from timer call
+ * @return 0
+ */
 int unit_teleport_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	struct block_list *bl = map_id2bl(id);
@@ -184,11 +197,11 @@ int unit_teleport_timer(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Checks if a slave unit is outside their max distance from master \n
-* If so, starts a timer for (default: 3 seconds) which will teleport the unit back to master
-* @param sbl: Object with a master [MOB|PET|HOM|MER|ELEM]
-* @return 0
-**/
+ * Checks if a slave unit is outside their max distance from master \n
+ * If so, starts a timer for (default: 3 seconds) which will teleport the unit back to master
+ * @param sbl: Object with a master [MOB|PET|HOM|MER|ELEM]
+ * @return 0
+ */
 int unit_check_start_teleport_timer(struct block_list *sbl)
 {
 	TBL_PC *msd = unit_get_master(sbl);
@@ -217,13 +230,13 @@ int unit_check_start_teleport_timer(struct block_list *sbl)
 }
 
 /**
-* Defines when to refresh the walking character to object and restart the timer if applicable \n
-* Also checks for speed update, target location, and slave teleport timers
-* @param tid: Timer ID
-* @param tick: Current tick to decide next timer update
-* @param data: Data used in timer calls
-* @return 0 or unit_walktoxy_sub()
-**/
+ * Defines when to refresh the walking character to object and restart the timer if applicable \n
+ * Also checks for speed update, target location, and slave teleport timers
+ * @param tid: Timer ID
+ * @param tick: Current tick to decide next timer update
+ * @param data: Data used in timer calls
+ * @return 0 or unit_walktoxy_sub()
+ */
 static int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	int i;
@@ -388,13 +401,13 @@ static int unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data
 }
 
 /**
-* Delays an xy timer
-* @param tid: Timer ID
-* @param tick: Unused
-* @param id: ID of bl to delay timer on
-* @param data: Data used in timer calls
-* @return 1: Success 0: Fail (No valid bl)
-**/
+ * Delays an xy timer
+ * @param tid: Timer ID
+ * @param tick: Unused
+ * @param id: ID of bl to delay timer on
+ * @param data: Data used in timer calls
+ * @return 1: Success 0: Fail (No valid bl)
+ */
 int unit_delay_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	struct block_list *bl = map_id2bl(id);
@@ -406,13 +419,13 @@ int unit_delay_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Delays an walk-to-bl timer
-* @param tid: Timer ID
-* @param tick: Unused
-* @param id: ID of bl to delay timer on
-* @param data: Data used in timer calls (target bl)
-* @return 1: Success 0: Fail (No valid bl or target)
-**/
+ * Delays an walk-to-bl timer
+ * @param tid: Timer ID
+ * @param tick: Unused
+ * @param id: ID of bl to delay timer on
+ * @param data: Data used in timer calls (target bl)
+ * @return 1: Success 0: Fail (No valid bl or target)
+ */
 int unit_delay_walktobl_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	struct block_list *bl = map_id2bl(id), *tbl = map_id2bl(data);
@@ -428,17 +441,17 @@ int unit_delay_walktobl_timer(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Begins the function of walking a unit to an x,y location \n
-* This is where the path searches and unit can_move checks are done
-* @param bl: Object to send to x,y coordinate
-* @param x: X coordinate where the object will be walking to
-* @param y: Y coordinate where the object will be walking to
-* @param flag: Parameter to decide how to walk \n
-*	&1: Easy walk (fail if CELL_CHKNOPASS is in direct path) \n
-*	&2: Force walking (override can_move) \n
-*	&4: Delay walking for can_move
-* @return 1: Success 0: Fail or unit_walktoxy_sub()
-**/
+ * Begins the function of walking a unit to an x,y location \n
+ * This is where the path searches and unit can_move checks are done
+ * @param bl: Object to send to x,y coordinate
+ * @param x: X coordinate where the object will be walking to
+ * @param y: Y coordinate where the object will be walking to
+ * @param flag: Parameter to decide how to walk \n
+ *	&1: Easy walk (fail if CELL_CHKNOPASS is in direct path) \n
+ *	&2: Force walking (override can_move) \n
+ *	&4: Delay walking for can_move
+ * @return 1: Success 0: Fail or unit_walktoxy_sub()
+ */
 int unit_walktoxy( struct block_list *bl, short x, short y, int flag)
 {
 	struct unit_data* ud = NULL;
@@ -496,11 +509,11 @@ int unit_walktoxy( struct block_list *bl, short x, short y, int flag)
 }
 
 /**
-* Sets a mob's CHASE/FOLLOW state \n
-* This should not be done if there's no path to reach
-* @param bl: Mob to set state on
-* @param flag: Whether to set state or not
-**/
+ * Sets a mob's CHASE/FOLLOW state \n
+ * This should not be done if there's no path to reach
+ * @param bl: Mob to set state on
+ * @param flag: Whether to set state or not
+ */
 static inline void set_mobstate(struct block_list* bl, int flag)
 {
 	struct mob_data* md = BL_CAST(BL_MOB,bl);
@@ -510,13 +523,13 @@ static inline void set_mobstate(struct block_list* bl, int flag)
 }
 
 /**
-* Timer to walking a unit to another unit's location \n
-* Calls unit_walktoxy_sub once determined the unit can move
-* @param tid: Object's timer ID
-* @param id: Object's ID
-* @param data: Data passed through timer function (target)
-* @return 0
-**/
+ * Timer to walking a unit to another unit's location \n
+ * Calls unit_walktoxy_sub once determined the unit can move
+ * @param tid: Object's timer ID
+ * @param id: Object's ID
+ * @param data: Data passed through timer function (target)
+ * @return 0
+ */
 static int unit_walktobl_sub(int tid, unsigned int tick, int id, intptr_t data)
 {
 	struct block_list *bl = map_id2bl(id);
@@ -534,15 +547,15 @@ static int unit_walktobl_sub(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Tells a unit to walk to a target's location (chase)
-* @param bl: Object that is walking to target
-* @param tbl: Target object
-* @param range: How close to get to target (or attack range if flag&2)
-* @param flag: Extra behaviour \n
-*	&1: Use hard path seek (obstacles will be walked around if possible) \n
-*	&2: Start attacking upon arrival within range, otherwise just walk to target
-* @return 1: Started walking or set timer 0: Failed
-**/
+ * Tells a unit to walk to a target's location (chase)
+ * @param bl: Object that is walking to target
+ * @param tbl: Target object
+ * @param range: How close to get to target (or attack range if flag&2)
+ * @param flag: Extra behaviour \n
+ *	&1: Use hard path seek (obstacles will be walked around if possible) \n
+ *	&2: Start attacking upon arrival within range, otherwise just walk to target
+ * @return 1: Started walking or set timer 0: Failed
+ */
 int unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int flag)
 {
 	struct unit_data *ud = NULL;
@@ -601,10 +614,10 @@ int unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int
 }
 
 /**
-* Set a unit to run, checking for obstacles
-* @param bl: Object that is running
-* @return 1: Success 0: Fail
-**/
+ * Set a unit to run, checking for obstacles
+ * @param bl: Object that is running
+ * @return 1: Success 0: Fail
+ */
 int unit_run(struct block_list *bl)
 {
 	struct status_change *sc = status_get_sc(bl);
@@ -675,12 +688,13 @@ int unit_run(struct block_list *bl)
 	return 1;
 }
 
-/** [Jobbie/3CeAM] \n
-* Exclusive function used for Wug Dash
-* @param bl: Object that is dashing
-* @param sd: Player
-* @return 1: Success 0: Fail
-**/
+/**
+ * Char movement with wugdash
+ * @author [Jobbie/3CeAM]
+ * @param bl: Object that is dashing
+ * @param sd: Player
+ * @return 1: Success 0: Fail
+ */
 int unit_wugdash(struct block_list *bl, struct map_session_data *sd)
 {
 	struct status_change *sc = status_get_sc(bl);
@@ -690,7 +704,7 @@ int unit_wugdash(struct block_list *bl, struct map_session_data *sd)
 	if (!(sc && sc->data[SC_WUGDASH]))
 		return 0;
 
-	nullpo_ret(sd);
+	nullpo_ret(sd); //FIXME do we really need that check since we rechecking afterward
 	nullpo_ret(bl);
 
 	if (!unit_can_move(bl)) {
@@ -746,12 +760,12 @@ int unit_wugdash(struct block_list *bl, struct map_session_data *sd)
 }
 
 /**
-* Makes unit attempt to run away from target using hard paths
-* @param bl: Object that is running away from target
-* @param target: Target
-* @param dist: How far bl should run
-* @return 1: Success 0: Fail
-**/
+ * Makes unit attempt to run away from target using hard paths
+ * @param bl: Object that is running away from target
+ * @param target: Target
+ * @param dist: How far bl should run
+ * @return 1: Success 0: Fail
+ */
 int unit_escape(struct block_list *bl, struct block_list *target, short dist)
 {
 	uint8 dir = map_calc_dir(target, bl->x, bl->y);
@@ -761,14 +775,14 @@ int unit_escape(struct block_list *bl, struct block_list *target, short dist)
 }
 
 /**
-* Instant warps a unit to x,y coordinate
-* @param bl: Object to instant warp
-* @param dst_x: X coordinate to warp to
-* @param dst_y: Y coordinate to warp to
-* @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
-* @param checkpath: Whether or not to do a cell and path check for NOPASS and NOREACH
-* @return 1: Success 0: Fail
-**/
+ * Instant warps a unit to x,y coordinate
+ * @param bl: Object to instant warp
+ * @param dst_x: X coordinate to warp to
+ * @param dst_y: Y coordinate to warp to
+ * @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
+ * @param checkpath: Whether or not to do a cell and path check for NOPASS and NOREACH
+ * @return 1: Success 0: Fail
+ */
 int unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath)
 {
 	short dx,dy;
@@ -833,11 +847,11 @@ int unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool
 }
 
 /**
-* Sets direction of a unit
-* @param bl: Object to set direction
-* @param dir: Direction (0-7)
-* @return 0
-**/
+ * Sets direction of a unit
+ * @param bl: Object to set direction
+ * @param dir: Direction (0-7)
+ * @return 0
+ */
 int unit_setdir(struct block_list *bl,unsigned char dir)
 {
 	struct unit_data *ud;
@@ -852,10 +866,10 @@ int unit_setdir(struct block_list *bl,unsigned char dir)
 }
 
 /**
-* Gets direction of a unit
-* @param bl: Object to get direction
-* @return direction (0-7)
-**/
+ * Gets direction of a unit
+ * @param bl: Object to get direction
+ * @return direction (0-7)
+ */
 uint8 unit_getdir(struct block_list *bl)
 {
 	struct unit_data *ud;
@@ -866,15 +880,15 @@ uint8 unit_getdir(struct block_list *bl)
 }
 
 /**
-* Pushes a unit in a direction by a given amount of cells \n
-* There is no path check, only map cell restrictions are respected
-* @param bl: Object to push
-* @param dx: Destination cell X
-* @param dy: Destination cell Y
-* @param count: How many cells to push bl
-* @param flag: Whether or not to send position packet updates
-* @return count (can be modified due to map cell restrictions)
-**/
+ * Pushes a unit in a direction by a given amount of cells \n
+ * There is no path check, only map cell restrictions are respected
+ * @param bl: Object to push
+ * @param dx: Destination cell X
+ * @param dy: Destination cell Y
+ * @param count: How many cells to push bl
+ * @param flag: Whether or not to send position packet updates
+ * @return count (can be modified due to map cell restrictions)
+ */
 int unit_blown(struct block_list* bl, int dx, int dy, int count, int flag)
 {
 	if(count) {
@@ -934,16 +948,16 @@ int unit_blown(struct block_list* bl, int dx, int dy, int count, int flag)
 }
 
 /**
-* Warps a unit to a map/position \n
-* pc_setpos is used for player warping \n
-* This function checks for "no warp" map flags, so it's safe to call without doing nowarpto/nowarp checks
-* @param bl: Object to warp
-* @param m: Map ID from bl structure (NOT index)
-* @param x: Destination cell X
-* @param y: Destination cell Y
-* @param type: Clear type used in clif_clearunit_area()
-* @return Success(0); Failed(1); Error(2); unit_remove_map() Failed(3); map_addblock Failed(4)
-**/
+ * Warps a unit to a map/position \n
+ * pc_setpos is used for player warping \n
+ * This function checks for "no warp" map flags, so it's safe to call without doing nowarpto/nowarp checks
+ * @param bl: Object to warp
+ * @param m: Map ID from bl structure (NOT index)
+ * @param x: Destination cell X
+ * @param y: Destination cell Y
+ * @param type: Clear type used in clif_clearunit_area()
+ * @return Success(0); Failed(1); Error(2); unit_remove_map() Failed(3); map_addblock Failed(4)
+ */
 int unit_warp(struct block_list *bl,short m,short x,short y,clr_type type)
 {
 	struct unit_data *ud;
@@ -1011,15 +1025,15 @@ int unit_warp(struct block_list *bl,short m,short x,short y,clr_type type)
 }
 
 /**
-* Stops a unit from walking
-* @param bl: Object to stop walking
-* @param type: Options \n
-*	&0x1: Issue a fixpos packet afterwards \n
-*	&0x2: Force the unit to move one cell if it hasn't yet \n
-*	&0x4: Enable moving to the next cell when unit was already half-way there \n
-*		(may cause on-touch/place side-effects, such as a scripted map change)
-* @return Success(1); Failed(0);
-**/
+ * Stops a unit from walking
+ * @param bl: Object to stop walking
+ * @param type: Options \n
+ *	&0x1: Issue a fixpos packet afterwards \n
+ *	&0x2: Force the unit to move one cell if it hasn't yet \n
+ *	&0x4: Enable moving to the next cell when unit was already half-way there \n
+ *		(may cause on-touch/place side-effects, such as a scripted map change)
+ * @return Success(1); Failed(0);
+ */
 int unit_stop_walking(struct block_list *bl,int type)
 {
 	struct unit_data *ud;
@@ -1064,13 +1078,13 @@ int unit_stop_walking(struct block_list *bl,int type)
 }
 
 /**
-* Initiates a skill use by a unit
-* @param src: Source object initiating skill use
-* @param target_id: Target ID (bl->id)
-* @param skill_id: Skill ID
-* @param skill_lv: Skill Level
-* @return unit_skilluse_id2()
-**/
+ * Initiates a skill use by a unit
+ * @param src: Source object initiating skill use
+ * @param target_id: Target ID (bl->id)
+ * @param skill_id: Skill ID
+ * @param skill_lv: Skill Level
+ * @return unit_skilluse_id2()
+ */
 int unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv)
 {
 	return unit_skilluse_id2(
@@ -1081,10 +1095,10 @@ int unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uin
 }
 
 /**
-* Checks if a unit is walking
-* @param bl: Object to check walk status
-* @return Walking(1); Not Walking(0)
-**/
+ * Checks if a unit is walking
+ * @param bl: Object to check walk status
+ * @return Walking(1); Not Walking(0)
+ */
 int unit_is_walking(struct block_list *bl)
 {
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -1093,13 +1107,14 @@ int unit_is_walking(struct block_list *bl)
 	return (ud->walktimer != INVALID_TIMER);
 }
 
-/** [Skotlex] \n
-* Checks if a unit is able to move based on status changes \n
-* View the StatusChangeStateTable in status.c for a list of statuses \n
-* Some statuses are still checked here due too specific variables
-* @param bl: Object to check
-* @return Can move(1); Can't move(0)
-**/
+/** 
+ * Checks if a unit is able to move based on status changes \n
+ * View the StatusChangeStateTable in status.c for a list of statuses \n
+ * Some statuses are still checked here due too specific variables
+ * @author [Skotlex]
+ * @param bl: Object to check
+ * @return Can move(1); Can't move(0)
+ */
 int unit_can_move(struct block_list *bl) {
 	struct map_session_data *sd;
 	struct unit_data *ud;
@@ -1150,12 +1165,12 @@ int unit_can_move(struct block_list *bl) {
 }
 
 /**
-* Resumes running (RA_WUGDASH or TK_RUN) after a walk delay
-* @param tid: Timer ID
-* @param id: Object ID
-* @param data: Data passed through timer function (unit_data)
-* @return 0
-**/
+ * Resumes running (RA_WUGDASH or TK_RUN) after a walk delay
+ * @param tid: Timer ID
+ * @param id: Object ID
+ * @param data: Data passed through timer function (unit_data)
+ * @return 0
+ */
 int unit_resume_running(int tid, unsigned int tick, int id, intptr_t data)
 {
 
@@ -1176,15 +1191,15 @@ int unit_resume_running(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Applies a walk delay to a unit
-* @param bl: Object to apply walk delay to
-* @param tick: Current tick
-* @param delay: Amount of time to set walk delay
-* @param type: Type of delay \n
-*	0: Damage induced delay; Do not change previous delay \n
-*	1: Skill induced delay; Walk delay can only be increased, not decreased
-* @return Success(1); Fail(0);
-**/
+ * Applies a walk delay to a unit
+ * @param bl: Object to apply walk delay to
+ * @param tick: Current tick
+ * @param delay: Amount of time to set walk delay
+ * @param type: Type of delay \n
+ *	0: Damage induced delay; Do not change previous delay \n
+ *	1: Skill induced delay; Walk delay can only be increased, not decreased
+ * @return Success(1); Fail(0);
+ */
 int unit_set_walkdelay(struct block_list *bl, unsigned int tick, int delay, int type)
 {
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -1221,15 +1236,15 @@ int unit_set_walkdelay(struct block_list *bl, unsigned int tick, int delay, int
 }
 
 /**
-* Performs checks for a unit using a skill and executes after cast time completion
-* @param src: Object using skill
-* @param target_id: Target ID (bl->id)
-* @param skill_id: Skill ID
-* @param skill_lv: Skill Level
-* @param casttime: Initial cast time before cast time reductions
-* @param castcancel: Whether or not the skill can be cancelled by interuption (hit)
-* @return Success(1); Fail(0);
-**/
+ * Performs checks for a unit using a skill and executes after cast time completion
+ * @param src: Object using skill
+ * @param target_id: Target ID (bl->id)
+ * @param skill_id: Skill ID
+ * @param skill_lv: Skill Level
+ * @param casttime: Initial cast time before cast time reductions
+ * @param castcancel: Whether or not the skill can be cancelled by interuption (hit)
+ * @return Success(1); Fail(0);
+ */
 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;
@@ -1584,14 +1599,14 @@ int unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, ui
 }
 
 /**
-* Initiates a placement (ground/non-targeted) skill
-* @param src: Object using skill
-* @param skill_x: X coordinate where skill is being casted (center)
-* @param skill_y: Y coordinate where skill is being casted (center)
-* @param skill_id: Skill ID
-* @param skill_lv: Skill Level
-* @return unit_skilluse_pos2()
-**/
+ * Initiates a placement (ground/non-targeted) skill
+ * @param src: Object using skill
+ * @param skill_x: X coordinate where skill is being casted (center)
+ * @param skill_y: Y coordinate where skill is being casted (center)
+ * @param skill_id: Skill ID
+ * @param skill_lv: Skill Level
+ * @return unit_skilluse_pos2()
+ */
 int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv)
 {
 	return unit_skilluse_pos2(
@@ -1602,16 +1617,16 @@ int unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint
 }
 
 /**
-* Performs checks for a unit using a skill and executes after cast time completion
-* @param src: Object using skill
-* @param skill_x: X coordinate where skill is being casted (center)
-* @param skill_y: Y coordinate where skill is being casted (center)
-* @param skill_id: Skill ID
-* @param skill_lv: Skill Level
-* @param casttime: Initial cast time before cast time reductions
-* @param castcancel: Whether or not the skill can be cancelled by interuption (hit)
-* @return Success(1); Fail(0);
-**/
+ * Performs checks for a unit using a skill and executes after cast time completion
+ * @param src: Object using skill
+ * @param skill_x: X coordinate where skill is being casted (center)
+ * @param skill_y: Y coordinate where skill is being casted (center)
+ * @param skill_id: Skill ID
+ * @param skill_lv: Skill Level
+ * @param casttime: Initial cast time before cast time reductions
+ * @param castcancel: Whether or not the skill can be cancelled by interuption (hit)
+ * @return Success(1); Fail(0);
+ */
 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;
@@ -1747,11 +1762,11 @@ int unit_skilluse_pos2( struct block_list *src, short skill_x, short skill_y, ui
 }
 
 /**
-* Update a unit's attack target
-* @param ud: Unit data
-* @param target_id: Target ID (bl->id)
-* @return 0
-**/
+ * Update a unit's attack target
+ * @param ud: Unit data
+ * @param target_id: Target ID (bl->id)
+ * @return 0
+ */
 int unit_set_target(struct unit_data* ud, int target_id)
 {
 	struct unit_data * ux;
@@ -1771,10 +1786,10 @@ int unit_set_target(struct unit_data* ud, int target_id)
 }
 
 /**
-* Stop a unit's attacks
-* @param bl: Object to stop
-* @return 0
-**/
+ * Stop a unit's attacks
+ * @param bl: Object to stop
+ * @return 0
+ */
 int unit_stop_attack(struct block_list *bl)
 {
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -1790,10 +1805,10 @@ int unit_stop_attack(struct block_list *bl)
 }
 
 /**
-* Removes a unit's target due to being unattackable
-* @param bl: Object to unlock target
-* @return 0
-**/
+ * Removes a unit's target due to being unattackable
+ * @param bl: Object to unlock target
+ * @return 0
+ */
 int unit_unattackable(struct block_list *bl)
 {
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -1810,12 +1825,12 @@ int unit_unattackable(struct block_list *bl)
 }
 
 /**
-* Requests a unit to attack a target
-* @param src: Object initiating attack
-* @param target_id: Target ID (bl->id)
-* @param continuous: Whether or not the attack is ongoing
-* @return Success(0); Fail(1);
-**/
+ * Requests a unit to attack a target
+ * @param src: Object initiating attack
+ * @param target_id: Target ID (bl->id)
+ * @param continuous: Whether or not the attack is ongoing
+ * @return Success(0); Fail(1);
+ */
 int unit_attack(struct block_list *src,int target_id,int continuous)
 {
 	struct block_list *target;
@@ -1867,12 +1882,13 @@ int unit_attack(struct block_list *src,int target_id,int continuous)
 	return 0;
 }
 
-/** [Skotlex] \n
-* Cancels an ongoing combo, resets attackable time, and restarts the \n
-* attack timer to resume attack after amotion time
-* @param bl: Object to cancel combo
-* @return Success(1); Fail(0);
-**/
+/** 
+ * Cancels an ongoing combo, resets attackable time, and restarts the \n
+ * attack timer to resume attack after amotion time
+ * @author [Skotlex]
+ * @param bl: Object to cancel combo
+ * @return Success(1); Fail(0);
+ */
 int unit_cancel_combo(struct block_list *bl)
 {
 	struct unit_data  *ud;
@@ -1894,13 +1910,13 @@ int unit_cancel_combo(struct block_list *bl)
 }
 
 /**
-* Does a path_search to check if a position can be reached
-* @param bl: Object to check path
-* @param x: X coordinate that will be path searched
-* @param y: Y coordinate that will be path searched
-* @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
-* @return true or false
-**/
+ * Does a path_search to check if a position can be reached
+ * @param bl: Object to check path
+ * @param x: X coordinate that will be path searched
+ * @param y: Y coordinate that will be path searched
+ * @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
+ * @return true or false
+ */
 bool unit_can_reach_pos(struct block_list *bl,int x,int y, int easy)
 {
 	nullpo_retr(false, bl);
@@ -1912,15 +1928,15 @@ bool unit_can_reach_pos(struct block_list *bl,int x,int y, int easy)
 }
 
 /**
-* Does a path_search to check if a unit can be reached
-* @param bl: Object to check path
-* @param tbl: Target to be checked for available path
-* @param range: The number of cells away from bl that the path should be checked
-* @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
-* @param x: Pointer storing a valid X coordinate around tbl that can be reached
-* @param y: Pointer storing a valid Y coordinate around tbl that can be reached
-* @return true or false
-**/
+ * Does a path_search to check if a unit can be reached
+ * @param bl: Object to check path
+ * @param tbl: Target to be checked for available path
+ * @param range: The number of cells away from bl that the path should be checked
+ * @param easy: Easy(1) or Hard(0) path check (hard attempts to go around obstacles)
+ * @param x: Pointer storing a valid X coordinate around tbl that can be reached
+ * @param y: Pointer storing a valid Y coordinate around tbl that can be reached
+ * @return true or false
+ */
 bool unit_can_reach_bl(struct block_list *bl,struct block_list *tbl, int range, int easy, short *x, short *y)
 {
 	int i;
@@ -1956,13 +1972,13 @@ bool unit_can_reach_bl(struct block_list *bl,struct block_list *tbl, int range,
 }
 
 /**
-* Calculates position of Pet/Mercenary/Homunculus/Elemental
-* @param bl: Object to calculate position
-* @param tx: X coordinate to go to
-* @param ty: Y coordinate to go to
-* @param dir: Direction which to be 2 cells from master's position
-* @return Success(0); Fail(1);
-**/
+ * Calculates position of Pet/Mercenary/Homunculus/Elemental
+ * @param bl: Object to calculate position
+ * @param tx: X coordinate to go to
+ * @param ty: Y coordinate to go to
+ * @param dir: Direction which to be 2 cells from master's position
+ * @return Success(0); Fail(1);
+ */
 int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir)
 {
 	int dx, dy, x, y, i, k;
@@ -2014,12 +2030,12 @@ int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir)
 }
 
 /**
-* Function timer to continuously attack
-* @param src: Object to continuously attack
-* @param tid: Timer ID
-* @param tick: Current tick
-* @return Attackable(1); Unattackable(0);
-**/
+ * Function timer to continuously attack
+ * @param src: Object to continuously attack
+ * @param tid: Timer ID
+ * @param tick: Current tick
+ * @return Attackable(1); Unattackable(0);
+ */
 static int unit_attack_timer_sub(struct block_list* src, int tid, unsigned int tick)
 {
 	struct block_list *target;
@@ -2153,13 +2169,13 @@ static int unit_attack_timer_sub(struct block_list* src, int tid, unsigned int t
 }
 
 /**
-* Timer function to cancel attacking if unit has become unattackable
-* @param tid: Timer ID
-* @param tick: Current tick
-* @param id: Object to cancel attack if applicable
-* @param data: Data passed from timer call
-* @return 0
-**/
+ * Timer function to cancel attacking if unit has become unattackable
+ * @param tid: Timer ID
+ * @param tick: Current tick
+ * @param id: Object to cancel attack if applicable
+ * @param data: Data passed from timer call
+ * @return 0
+ */
 static int unit_attack_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
 	struct block_list *bl;
@@ -2170,13 +2186,13 @@ static int unit_attack_timer(int tid, unsigned int tick, int id, intptr_t data)
 }
 
 /**
-* Cancels a skill's cast
-* @param bl: Object to cancel cast
-* @param type: Cancel check flag \n
-*	&1: Cast-Cancel invoked \n
-*	&2: Cancel only if skill is cancellable
-* @return Success(1); Fail(0);
-**/
+ * Cancels a skill's cast
+ * @param bl: Object to cancel cast
+ * @param type: Cancel check flag \n
+ *	&1: Cast-Cancel invoked \n
+ *	&2: Cancel only if skill is cancellable
+ * @return Success(1); Fail(0);
+ */
 int unit_skillcastcancel(struct block_list *bl,int type)
 {
 	struct map_session_data *sd = NULL;
@@ -2233,9 +2249,9 @@ int unit_skillcastcancel(struct block_list *bl,int type)
 }
 
 /**
-* Initialized data on a unit
-* @param bl: Object to initialize data on
-**/
+ * Initialized data on a unit
+ * @param bl: Object to initialize data on
+ */
 void unit_dataset(struct block_list *bl)
 {
 	struct unit_data *ud;
@@ -2252,10 +2268,10 @@ void unit_dataset(struct block_list *bl)
 }
 
 /**
-* Gets the number of units attacking another unit
-* @param bl: Object to check amount of targets
-* @return number of targets or 0
-**/
+ * Gets the number of units attacking another unit
+ * @param bl: Object to check amount of targets
+ * @return number of targets or 0
+ */
 int unit_counttargeted(struct block_list* bl)
 {
 	struct unit_data* ud;
@@ -2265,24 +2281,11 @@ int unit_counttargeted(struct block_list* bl)
 }
 
 /**
-* Is this even used?  Why is it a function?
-**/
-int unit_fixdamage(struct block_list *src,struct block_list *target,unsigned int tick,int sdelay,int ddelay,int64 damage,int div,int type,int64 damage2)
-{
-	nullpo_ret(target);
-
-	if(damage+damage2 <= 0)
-		return 0;
-
-	return status_fix_damage(src,target,damage+damage2,clif_damage(target,target,tick,sdelay,ddelay,damage,div,type,damage2));
-}
-
-/**
-* Changes the size of a unit
-* @param bl: Object to change size [PC|MOB]
-* @param size: New size of bl
-* @return 0
-**/
+ * Changes the size of a unit
+ * @param bl: Object to change size [PC|MOB]
+ * @param size: New size of bl
+ * @return 0
+ */
 int unit_changeviewsize(struct block_list *bl,short size)
 {
 	nullpo_ret(bl);
@@ -2301,15 +2304,15 @@ int unit_changeviewsize(struct block_list *bl,short size)
 }
 
 /**
-* Removes a bl/ud from the map \n
-* On kill specifics are not performed here, check status_damage()
-* @param bl: Object to remove from map
-* @param clrtype: How bl is being removed \n
-*	0: Assume bl is being warped \n
-*	1: Death, appropriate cleanup performed
-* @param file, line, func: Call information for debug purposes
-* @return Success(1); Couldn't be removed or bl was free'd(0)
-**/
+ * Removes a bl/ud from the map \n
+ * On kill specifics are not performed here, check status_damage()
+ * @param bl: Object to remove from map
+ * @param clrtype: How bl is being removed \n
+ *	0: Assume bl is being warped \n
+ *	1: Death, appropriate cleanup performed
+ * @param file, line, func: Call information for debug purposes
+ * @return Success(1); Couldn't be removed or bl was free'd(0)
+ */
 int unit_remove_map_(struct block_list *bl, clr_type clrtype, const char* file, int line, const char* func)
 {
 	struct unit_data *ud = unit_bl2ud(bl);
@@ -2537,12 +2540,12 @@ int unit_remove_map_(struct block_list *bl, clr_type clrtype, const char* file,
 }
 
 /**
-* Removes units of a master when the master is removed from map
-* @param sd: Player
-* @param clrtype: How bl is being removed \n
-*	0: Assume bl is being warped \n
-*	1: Death, appropriate cleanup performed
-**/
+ * Removes units of a master when the master is removed from map
+ * @param sd: Player
+ * @param clrtype: How bl is being removed \n
+ *	0: Assume bl is being warped \n
+ *	1: Death, appropriate cleanup performed
+ */
 void unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype)
 {
 	unit_remove_map(&sd->bl,clrtype);
@@ -2560,9 +2563,10 @@ void unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype)
 }
 
 /**
-* Frees units of a master when the master is removed from map
-* @param sd: Player
-**/
+ * Frees units of a player when is removed from map
+ * Also free his pets/homon/mercenary/elemental/etc if he have any
+ * @param sd: Player
+ */
 void unit_free_pc(struct map_session_data *sd)
 {
 	if (sd->pd) unit_free(&sd->pd->bl,CLR_OUTSIGHT);
@@ -2573,13 +2577,13 @@ void unit_free_pc(struct map_session_data *sd)
 }
 
 /**
-* Frees all related resources to the unit
-* @param bl: Object being removed from map
-* @param clrtype: How bl is being removed \n
-*	0: Assume bl is being warped \n
-*	1: Death, appropriate cleanup performed
-* @return 0
-**/
+ * Frees all related resources to the unit
+ * @param bl: Object being removed from map
+ * @param clrtype: How bl is being removed \n
+ *	0: Assume bl is being warped \n
+ *	1: Death, appropriate cleanup performed
+ * @return 0
+ */
 int unit_free(struct block_list *bl, clr_type clrtype)
 {
 	struct unit_data *ud = unit_bl2ud( bl );
@@ -2803,8 +2807,9 @@ int unit_free(struct block_list *bl, clr_type clrtype)
 }
 
 /**
-* Initialization function for unit on map start
-**/
+ * Initialization function for unit on map start
+ * called in map::do_init
+ */
 int do_init_unit(void)
 {
 	add_timer_func_list(unit_attack_timer,  "unit_attack_timer");
@@ -2816,6 +2821,11 @@ int do_init_unit(void)
 	return 0;
 }
 
+/**
+ * Unit module destructor, (thing to do before closing the module)
+ * called in map::do_final
+ * @return 0
+ */
 int do_final_unit(void)
 {
 	// Nothing to do
diff --git a/src/map/unit.h b/src/map/unit.h
index 467dec3a4f..e21d557f0d 100644
--- a/src/map/unit.h
+++ b/src/map/unit.h
@@ -14,9 +14,12 @@ struct map_session_data;
 #include "path.h" // struct walkpath_data
 #include "skill.h" // struct skill_timerskill, struct skill_unit_group, struct skill_unit_group_tickset
 
+extern const short dirx[8]; ///lookup to know where will move to x according dir
+extern const short diry[8]; ///lookup to know where will move to y according dir
+
 struct unit_data {
-	struct block_list *bl;
-	struct walkpath_data walkpath;
+	struct block_list *bl; ///link to owner object BL_CHAR (BL_PC|BL_HOM|BL_PET|BL_ELE|BL_MER)
+	struct walkpath_data walkpath; 
 	struct skill_timerskill *skilltimerskill[MAX_SKILLTIMERSKILL];
 	struct skill_unit_group *skillunit[MAX_SKILLUNITGROUP];
 	struct skill_unit_group_tickset skillunittick[MAX_SKILLUNITGROUPTICKSET];
@@ -78,6 +81,9 @@ int unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir);
 int unit_delay_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data);
 int unit_delay_walktobl_timer(int tid, unsigned int tick, int id, intptr_t data);
 
+// Ranger
+int unit_wugdash(struct block_list *bl, struct map_session_data *sd);
+
 // Causes the target object to stop moving.
 int unit_stop_walking(struct block_list *bl,int type);
 int unit_can_move(struct block_list *bl);
@@ -130,10 +136,5 @@ int unit_changeviewsize(struct block_list *bl,short size);
 int do_init_unit(void);
 int do_final_unit(void);
 
-// Ranger
-int unit_wugdash(struct block_list *bl, struct map_session_data *sd);
-
-extern const short dirx[8];
-extern const short diry[8];
 
 #endif /* _UNIT_H_ */
diff --git a/src/map/vending.c b/src/map/vending.c
index 1696b37482..37de8b0e51 100644
--- a/src/map/vending.c
+++ b/src/map/vending.c
@@ -20,21 +20,29 @@
 #include <stdio.h>
 #include <string.h>
 
-static int vending_nextid = 0;
-static DBMap *vending_db;
+static int vending_nextid = 0; ///Vending_id counter
+static DBMap *vending_db; ///Db holder the vender : charid -> map_session_data
 
+/**
+ * Lookup to get the vending_db outside module
+ * @return the vending_db
+ */
 DBMap * vending_getdb(){
 	return vending_db;
 }
-/// Returns an unique vending shop id.
-static int vending_getuid(void)
-{
+
+/**
+ * Create an unique vending shop id.
+ * @return the next vending_id
+ */
+static int vending_getuid(void){
 	return ++vending_nextid;
 }
 
-/*==========================================
- * Close shop
- *------------------------------------------*/
+/**
+ * Make a player close his shop
+ * @param sd : player session
+ */
 void vending_closevending(struct map_session_data* sd)
 {
 	nullpo_retv(sd);
@@ -46,9 +54,11 @@ void vending_closevending(struct map_session_data* sd)
 	}
 }
 
-/*==========================================
- * Request a shop's item list
- *------------------------------------------*/
+/**
+ * Player request a shop's item list (a player shop)
+ * @param sd : player requestion the list
+ * @param id : vender account id (gid)
+ */
 void vending_vendinglistreq(struct map_session_data* sd, int id)
 {
 	struct map_session_data* vsd;
@@ -70,9 +80,15 @@ void vending_vendinglistreq(struct map_session_data* sd, int id)
 	clif_vendinglist(sd, id, vsd->vending);
 }
 
-/*==========================================
+/**
  * Purchase item(s) from a shop
- *------------------------------------------*/
+ * @param sd : buyer player session
+ * @param aid : account id of vender
+ * @param uid : shop unique id
+ * @param data : items data who would like to purchase \n
+ *	data := {<index>.w <amount>.w }[count]
+ * @param count : number of different items he's trying to buy
+ */
 void vending_purchasereq(struct map_session_data* sd, int aid, int uid, const uint8* data, int count)
 {
 	int i, j, cursor, w, new_ = 0, blank, vend_list[MAX_VENDING];
@@ -226,10 +242,14 @@ void vending_purchasereq(struct map_session_data* sd, int aid, int uid, const ui
 	}
 }
 
-/*==========================================
- * Open shop
- * data := {<index>.w <amount>.w <value>.l}[count]
- *------------------------------------------*/
+/**
+ * Player setup a new shop
+ * @param sd : player opening the shop
+ * @param message : shop title
+ * @param data : itemlist data \n
+ *	data := {<index>.w <amount>.w <value>.l}[count]
+ * @param count : number of different items
+ */
 void vending_openvending(struct map_session_data* sd, const char* message, const uint8* data, int count) {
 	int i, j;
 	int vending_skill_lvl;
@@ -297,8 +317,12 @@ void vending_openvending(struct map_session_data* sd, const char* message, const
 	idb_put(vending_db, sd->status.char_id, sd);
 }
 
-
-/// Checks if an item is being sold in given player's vending.
+/**
+ * Checks if an item is being sold in given player's vending.
+ * @param sd : vender session (player)
+ * @param nameid : item id
+ * @return 0:not selling it, 1: yes
+ */
 bool vending_search(struct map_session_data* sd, unsigned short nameid) {
 	int i;
 
@@ -315,8 +339,13 @@ bool vending_search(struct map_session_data* sd, unsigned short nameid) {
 }
 
 
-/// Searches for all items in a vending, that match given ids, price and possible cards.
-/// @return Whether or not the search should be continued.
+
+/**
+ * Searches for all items in a vending, that match given ids, price and possible cards.
+ * @param sd : The vender session to search into
+ * @param s : parameter of the search (see s_search_store_search)
+ * @return Whether or not the search should be continued.
+ */
 bool vending_searchall(struct map_session_data* sd, const struct s_search_store_search* s) {
 	int i, c, slot;
 	unsigned int idx, cidx;
@@ -367,10 +396,19 @@ bool vending_searchall(struct map_session_data* sd, const struct s_search_store_
 
 	return true;
 }
+
+/**
+ * Initialise the vending module
+ * called in map::do_init
+ */
 void do_final_vending(void) {
 	db_destroy(vending_db);
 }
 
+/**
+ * Destory the vending module
+ * called in map::do_final
+ */
 void do_init_vending(void) {
 	vending_db = idb_alloc(DB_OPT_BASE);
 	vending_nextid = 0;
diff --git a/src/map/vending.h b/src/map/vending.h
index a9fcbca7e3..8c429d9e96 100644
--- a/src/map/vending.h
+++ b/src/map/vending.h
@@ -10,9 +10,9 @@ struct map_session_data;
 struct s_search_store_search;
 
 struct s_vending {
-	short index; //cart index (return item data)
-	short amount; //amout of the item for vending
-	unsigned int value; //at wich price
+	short index; /// cart index (return item data)
+	short amount; ///amout of the item for vending
+	unsigned int value; ///at wich price
 };
 
 DBMap * vending_getdb();