- Undid r16968: SVN Replaced with source:/trunk/src/@16966 (tid:74924).

[16969:16991/trunk/src/] will be re-committed in the next 24 hours.

git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@16992 54d463be-8e91-2dee-dedb-b68131a5f0ec

1 files changed, 2845 insertions, 2777 deletions

diff --git a/src/map/map.c b/src/map/map.c
index 69e343fb3..9238af9f9 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -61,7 +61,7 @@ char map_server_ip[32] = "127.0.0.1";
 char map_server_id[32] = "ragnarok";
 char map_server_pw[32] = "ragnarok";
 char map_server_db[32] = "ragnarok";
-Sql *mmysql_handle;
+Sql* mmysql_handle;
 
 int db_use_sqldbs = 0;
 char item_db_db[32] = "item_db";
@@ -78,7 +78,7 @@ int log_db_port = 3306;
 char log_db_id[32] = "ragnarok";
 char log_db_pw[32] = "ragnarok";
 char log_db_db[32] = "log";
-Sql *logmysql_handle;
+Sql* logmysql_handle;
 
 // This param using for sending mainchat
 // messages like whispers to this nick. [LuzZza]
@@ -94,14 +94,14 @@ char *MSG_CONF_NAME;
 char *GRF_PATH_FILENAME;
 
 // DBMap declaartion
-static DBMap *id_db=NULL; // int id -> struct block_list*
-static DBMap *pc_db=NULL; // int id -> struct map_session_data*
-static DBMap *mobid_db=NULL; // int id -> struct mob_data*
-static DBMap *bossid_db=NULL; // int id -> struct mob_data* (MVP db)
-static DBMap *map_db=NULL; // unsigned int mapindex -> struct map_data*
-static DBMap *nick_db=NULL; // int char_id -> struct charid2nick* (requested names of offline characters)
-static DBMap *charid_db=NULL; // int char_id -> struct map_session_data*
-static DBMap *regen_db=NULL; // int id -> struct block_list* (status_natural_heal processing)
+static DBMap* id_db=NULL; // int id -> struct block_list*
+static DBMap* pc_db=NULL; // int id -> struct map_session_data*
+static DBMap* mobid_db=NULL; // int id -> struct mob_data*
+static DBMap* bossid_db=NULL; // int id -> struct mob_data* (MVP db)
+static DBMap* map_db=NULL; // unsigned int mapindex -> struct map_data*
+static DBMap* nick_db=NULL; // int char_id -> struct charid2nick* (requested names of offline characters)
+static DBMap* charid_db=NULL; // int char_id -> struct map_session_data*
+static DBMap* regen_db=NULL; // int id -> struct block_list* (status_natural_heal processing)
 
 static int map_users=0;
 
@@ -126,26 +126,26 @@ int agit2_flag = 0;
 int night_flag = 0; // 0=day, 1=night [Yor]
 
 struct charid_request {
-    struct charid_request *next;
-    int charid;// who want to be notified of the nick
+	struct charid_request* next;
+	int charid;// who want to be notified of the nick
 };
 struct charid2nick {
-    char nick[NAME_LENGTH];
-    struct charid_request *requests;// requests of notification on this nick
+	char nick[NAME_LENGTH];
+	struct charid_request* requests;// requests of notification on this nick
 };
 
 // This is the main header found at the very beginning of the map cache
 struct map_cache_main_header {
-    uint32 file_size;
-    uint16 map_count;
+	uint32 file_size;
+	uint16 map_count;
 };
 
 // This is the header appended before every compressed map cells info in the map cache
 struct map_cache_map_info {
-    char name[MAP_NAME_LENGTH];
-    int16 xs;
-    int16 ys;
-    int32 len;
+	char name[MAP_NAME_LENGTH];
+	int16 xs;
+	int16 ys;
+	int32 len;
 };
 
 char db_path[256] = "db";
@@ -158,19 +158,19 @@ char wisp_server_name[NAME_LENGTH] = "Server"; // can be modified in char-server
 
 int console = 0;
 int enable_spy = 0; //To enable/disable @spy commands, which consume too much cpu time when sending packets. [Skotlex]
-int enable_grf = 0; //To enable/disable reading maps from GRF files, bypassing mapcache [blackhole89]
+int enable_grf = 0;	//To enable/disable reading maps from GRF files, bypassing mapcache [blackhole89]
 
 /*==========================================
  * server player count (of all mapservers)
  *------------------------------------------*/
 void map_setusers(int users)
 {
-    map_users = users;
+	map_users = users;
 }
 
 int map_getusers(void)
 {
-    return map_users;
+	return map_users;
 }
 
 /*==========================================
@@ -178,65 +178,67 @@ int map_getusers(void)
  *------------------------------------------*/
 int map_usercount(void)
 {
-    return pc_db->size(pc_db);
+	return pc_db->size(pc_db);
 }
 
 
 /*==========================================
  * Attempt to free a map blocklist
  *------------------------------------------*/
-int map_freeblock(struct block_list *bl)
+int map_freeblock (struct block_list *bl)
 {
-    nullpo_retr(block_free_lock, bl);
-    if (block_free_lock == 0 || block_free_count >= block_free_max) {
-        aFree(bl);
-        bl = NULL;
-        if (block_free_count >= block_free_max)
-            ShowWarning("map_freeblock: too many free block! %d %d\n", block_free_count, block_free_lock);
-    } else
-        block_free[block_free_count++] = bl;
+	nullpo_retr(block_free_lock, bl);
+	if (block_free_lock == 0 || block_free_count >= block_free_max)
+	{
+		aFree(bl);
+		bl = NULL;
+		if (block_free_count >= block_free_max)
+			ShowWarning("map_freeblock: too many free block! %d %d\n", block_free_count, block_free_lock);
+	} else
+		block_free[block_free_count++] = bl;
 
-    return block_free_lock;
+	return block_free_lock;
 }
 /*==========================================
  * Lock blocklist, (prevent map_freeblock usage)
  *------------------------------------------*/
-int map_freeblock_lock(void)
+int map_freeblock_lock (void)
 {
-    return ++block_free_lock;
+	return ++block_free_lock;
 }
 
 /*==========================================
  * Remove the lock on map_bl
  *------------------------------------------*/
-int map_freeblock_unlock(void)
+int map_freeblock_unlock (void)
 {
-    if ((--block_free_lock) == 0) {
-        int i;
-        for (i = 0; i < block_free_count; i++) {
-            aFree(block_free[i]);
-            block_free[i] = NULL;
-        }
-        block_free_count = 0;
-    } else if (block_free_lock < 0) {
-        ShowError("map_freeblock_unlock: lock count < 0 !\n");
-        block_free_lock = 0;
-    }
+	if ((--block_free_lock) == 0) {
+		int i;
+		for (i = 0; i < block_free_count; i++)
+		{
+			aFree(block_free[i]);
+			block_free[i] = NULL;
+		}
+		block_free_count = 0;
+	} else if (block_free_lock < 0) {
+		ShowError("map_freeblock_unlock: lock count < 0 !\n");
+		block_free_lock = 0;
+	}
 
-    return block_free_lock;
+	return block_free_lock;
 }
 
 // Timer function to check if there some remaining lock and remove them if so.
 // Called each 1s
 int map_freeblock_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
-    if (block_free_lock > 0) {
-        ShowError("map_freeblock_timer: block_free_lock(%d) is invalid.\n", block_free_lock);
-        block_free_lock = 1;
-        map_freeblock_unlock();
-    }
+	if (block_free_lock > 0) {
+		ShowError("map_freeblock_timer: block_free_lock(%d) is invalid.\n", block_free_lock);
+		block_free_lock = 1;
+		map_freeblock_unlock();
+	}
 
-    return 0;
+	return 0;
 }
 
 //
@@ -255,17 +257,17 @@ static struct block_list bl_head;
  *------------------------------------------*/
 static void map_addblcell(struct block_list *bl)
 {
-    if (bl->m<0 || bl->x<0 || bl->x>=map[bl->m].xs || bl->y<0 || bl->y>=map[bl->m].ys || !(bl->type&BL_CHAR))
-        return;
-    map[bl->m].cell[bl->x+bl->y*map[bl->m].xs].cell_bl++;
-    return;
+	if( bl->m<0 || bl->x<0 || bl->x>=map[bl->m].xs || bl->y<0 || bl->y>=map[bl->m].ys || !(bl->type&BL_CHAR) )
+		return;
+	map[bl->m].cell[bl->x+bl->y*map[bl->m].xs].cell_bl++;
+	return;
 }
 
 static void map_delblcell(struct block_list *bl)
 {
-    if (bl->m <0 || bl->x<0 || bl->x>=map[bl->m].xs || bl->y<0 || bl->y>=map[bl->m].ys || !(bl->type&BL_CHAR))
-        return;
-    map[bl->m].cell[bl->x+bl->y*map[bl->m].xs].cell_bl--;
+	if( bl->m <0 || bl->x<0 || bl->x>=map[bl->m].xs || bl->y<0 || bl->y>=map[bl->m].ys || !(bl->type&BL_CHAR) )
+		return;
+	map[bl->m].cell[bl->x+bl->y*map[bl->m].xs].cell_bl--;
 }
 #endif
 
@@ -273,89 +275,91 @@ static void map_delblcell(struct block_list *bl)
  * Adds a block to the map.
  * Returns 0 on success, 1 on failure (illegal coordinates).
  *------------------------------------------*/
-int map_addblock(struct block_list *bl)
-{
-    int m, x, y, pos;
-
-    nullpo_ret(bl);
-
-    if (bl->prev != NULL) {
-        ShowError("map_addblock: bl->prev != NULL\n");
-        return 1;
-    }
-
-    m = bl->m;
-    x = bl->x;
-    y = bl->y;
-    if (m < 0 || m >= map_num) {
-        ShowError("map_addblock: invalid map id (%d), only %d are loaded.\n", m, map_num);
-        return 1;
-    }
-    if (x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys) {
-        ShowError("map_addblock: out-of-bounds coordinates (\"%s\",%d,%d), map is %dx%d\n", map[m].name, x, y, map[m].xs, map[m].ys);
-        return 1;
-    }
-
-    pos = x/BLOCK_SIZE+(y/BLOCK_SIZE)*map[m].bxs;
-
-    if (bl->type == BL_MOB) {
-        bl->next = map[m].block_mob[pos];
-        bl->prev = &bl_head;
-        if (bl->next) bl->next->prev = bl;
-        map[m].block_mob[pos] = bl;
-    } else {
-        bl->next = map[m].block[pos];
-        bl->prev = &bl_head;
-        if (bl->next) bl->next->prev = bl;
-        map[m].block[pos] = bl;
-    }
+int map_addblock(struct block_list* bl)
+{
+	int m, x, y, pos;
+
+	nullpo_ret(bl);
+
+	if (bl->prev != NULL) {
+		ShowError("map_addblock: bl->prev != NULL\n");
+		return 1;
+	}
+
+	m = bl->m;
+	x = bl->x;
+	y = bl->y;
+	if( m < 0 || m >= map_num )
+	{
+		ShowError("map_addblock: invalid map id (%d), only %d are loaded.\n", m, map_num);
+		return 1;
+	}
+	if( x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys )
+	{
+		ShowError("map_addblock: out-of-bounds coordinates (\"%s\",%d,%d), map is %dx%d\n", map[m].name, x, y, map[m].xs, map[m].ys);
+		return 1;
+	}
+
+	pos = x/BLOCK_SIZE+(y/BLOCK_SIZE)*map[m].bxs;
+
+	if (bl->type == BL_MOB) {
+		bl->next = map[m].block_mob[pos];
+		bl->prev = &bl_head;
+		if (bl->next) bl->next->prev = bl;
+		map[m].block_mob[pos] = bl;
+	} else {
+		bl->next = map[m].block[pos];
+		bl->prev = &bl_head;
+		if (bl->next) bl->next->prev = bl;
+		map[m].block[pos] = bl;
+	}
 
 #ifdef CELL_NOSTACK
-    map_addblcell(bl);
+	map_addblcell(bl);
 #endif
 
-    return 0;
+	return 0;
 }
 
 /*==========================================
  * Removes a block from the map.
  *------------------------------------------*/
-int map_delblock(struct block_list *bl)
+int map_delblock(struct block_list* bl)
 {
-    int pos;
-    nullpo_ret(bl);
+	int pos;
+	nullpo_ret(bl);
 
     // blocklist (2ways chainlist)
-    if (bl->prev == NULL) {
-        if (bl->next != NULL) {
-            // can't delete block (already at the begining of the chain)
-            ShowError("map_delblock error : bl->next!=NULL\n");
-        }
-        return 0;
-    }
+	if (bl->prev == NULL) {
+		if (bl->next != NULL) {
+			// can't delete block (already at the begining of the chain)
+			ShowError("map_delblock error : bl->next!=NULL\n");
+		}
+		return 0;
+	}
 
 #ifdef CELL_NOSTACK
-    map_delblcell(bl);
+	map_delblcell(bl);
 #endif
 
-    pos = bl->x/BLOCK_SIZE+(bl->y/BLOCK_SIZE)*map[bl->m].bxs;
+	pos = bl->x/BLOCK_SIZE+(bl->y/BLOCK_SIZE)*map[bl->m].bxs;
 
-    if (bl->next)
-        bl->next->prev = bl->prev;
-    if (bl->prev == &bl_head) {
-        //Since the head of the list, update the block_list map of []
-        if (bl->type == BL_MOB) {
-            map[bl->m].block_mob[pos] = bl->next;
-        } else {
-            map[bl->m].block[pos] = bl->next;
-        }
-    } else {
-        bl->prev->next = bl->next;
-    }
-    bl->next = NULL;
-    bl->prev = NULL;
+	if (bl->next)
+		bl->next->prev = bl->prev;
+	if (bl->prev == &bl_head) {
+	//Since the head of the list, update the block_list map of []
+		if (bl->type == BL_MOB) {
+			map[bl->m].block_mob[pos] = bl->next;
+		} else {
+			map[bl->m].block[pos] = bl->next;
+		}
+	} else {
+		bl->prev->next = bl->next;
+	}
+	bl->next = NULL;
+	bl->prev = NULL;
 
-    return 0;
+	return 0;
 }
 
 /*==========================================
@@ -365,105 +369,107 @@ int map_delblock(struct block_list *bl)
  *------------------------------------------*/
 int map_moveblock(struct block_list *bl, int x1, int y1, unsigned int tick)
 {
-    int x0 = bl->x, y0 = bl->y;
-    struct status_change *sc = NULL;
-    int moveblock = (x0/BLOCK_SIZE != x1/BLOCK_SIZE || y0/BLOCK_SIZE != y1/BLOCK_SIZE);
-
-    if (!bl->prev) {
-        //Block not in map, just update coordinates, but do naught else.
-        bl->x = x1;
-        bl->y = y1;
-        return 0;
-    }
-
-    //TODO: Perhaps some outs of bounds checking should be placed here?
-    if (bl->type&BL_CHAR) {
-        sc = status_get_sc(bl);
-
-        skill_unit_move(bl,tick,2);
-        status_change_end(bl, SC_CLOSECONFINE, INVALID_TIMER);
-        status_change_end(bl, SC_CLOSECONFINE2, INVALID_TIMER);
-        //      status_change_end(bl, SC_BLADESTOP, INVALID_TIMER); //Won't stop when you are knocked away, go figure...
-        status_change_end(bl, SC_TATAMIGAESHI, INVALID_TIMER);
-        status_change_end(bl, SC_MAGICROD, INVALID_TIMER);
-        if (sc->data[SC_PROPERTYWALK] &&
-            sc->data[SC_PROPERTYWALK]->val3 >= skill_get_maxcount(sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2))
-            status_change_end(bl,SC_PROPERTYWALK,INVALID_TIMER);
-    } else if (bl->type == BL_NPC)
-        npc_unsetcells((TBL_NPC *)bl);
-
-    if (moveblock) map_delblock(bl);
+	int x0 = bl->x, y0 = bl->y;
+	struct status_change *sc = NULL;
+	int moveblock = ( x0/BLOCK_SIZE != x1/BLOCK_SIZE || y0/BLOCK_SIZE != y1/BLOCK_SIZE);
+
+	if (!bl->prev) {
+		//Block not in map, just update coordinates, but do naught else.
+		bl->x = x1;
+		bl->y = y1;
+		return 0;
+	}
+
+	//TODO: Perhaps some outs of bounds checking should be placed here?
+	if (bl->type&BL_CHAR) {
+		sc = status_get_sc(bl);
+
+		skill_unit_move(bl,tick,2);
+		status_change_end(bl, SC_CLOSECONFINE, INVALID_TIMER);
+		status_change_end(bl, SC_CLOSECONFINE2, INVALID_TIMER);
+//		status_change_end(bl, SC_BLADESTOP, INVALID_TIMER); //Won't stop when you are knocked away, go figure...
+		status_change_end(bl, SC_TATAMIGAESHI, INVALID_TIMER);
+		status_change_end(bl, SC_MAGICROD, INVALID_TIMER);
+		if (sc->data[SC_PROPERTYWALK] &&
+			sc->data[SC_PROPERTYWALK]->val3 >= skill_get_maxcount(sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2) )
+			status_change_end(bl,SC_PROPERTYWALK,INVALID_TIMER);
+	} else
+	if (bl->type == BL_NPC)
+		npc_unsetcells((TBL_NPC*)bl);
+
+	if (moveblock) map_delblock(bl);
 #ifdef CELL_NOSTACK
-    else map_delblcell(bl);
+	else map_delblcell(bl);
 #endif
-    bl->x = x1;
-    bl->y = y1;
-    if (moveblock) map_addblock(bl);
+	bl->x = x1;
+	bl->y = y1;
+	if (moveblock) map_addblock(bl);
 #ifdef CELL_NOSTACK
-    else map_addblcell(bl);
+	else map_addblcell(bl);
 #endif
 
-    if (bl->type&BL_CHAR) {
-
-        skill_unit_move(bl,tick,3);
-
-        if (bl->type == BL_PC && ((TBL_PC *)bl)->shadowform_id) {//Shadow Form Target Moving
-            struct block_list *d_bl;
-            if ((d_bl = map_id2bl(((TBL_PC *)bl)->shadowform_id)) == NULL || bl->m != d_bl->m || !check_distance_bl(bl,d_bl,10)) {
-                if (d_bl)
-                    status_change_end(d_bl,SC__SHADOWFORM,INVALID_TIMER);
-                ((TBL_PC *)bl)->shadowform_id = 0;
-            }
-        }
-
-        if (sc && sc->count) {
-            if (sc->data[SC_DANCING])
-                skill_unit_move_unit_group(skill_id2group(sc->data[SC_DANCING]->val2), bl->m, x1-x0, y1-y0);
-            else {
-                if (sc->data[SC_CLOAKING])
-                    skill_check_cloaking(bl, sc->data[SC_CLOAKING]);
-                if (sc->data[SC_WARM])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_WARM]->val4), bl->m, x1-x0, y1-y0);
-                if (sc->data[SC_BANDING])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_BANDING]->val4), bl->m, x1-x0, y1-y0);
-
-                if (sc->data[SC_NEUTRALBARRIER_MASTER])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_NEUTRALBARRIER_MASTER]->val2), bl->m, x1-x0, y1-y0);
-                else if (sc->data[SC_STEALTHFIELD_MASTER])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_STEALTHFIELD_MASTER]->val2), bl->m, x1-x0, y1-y0);
-
-                if (sc->data[SC__SHADOWFORM]) { //Shadow Form Caster Moving
-                    struct block_list *d_bl;
-                    if ((d_bl = map_id2bl(sc->data[SC__SHADOWFORM]->val2)) == NULL || bl->m != d_bl->m || !check_distance_bl(bl,d_bl,10))
-                        status_change_end(bl,SC__SHADOWFORM,INVALID_TIMER);
-                }
-
-                if (sc->data[SC_PROPERTYWALK]
-                    && sc->data[SC_PROPERTYWALK]->val3 < skill_get_maxcount(sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2)
-                    && map_find_skill_unit_oncell(bl,bl->x,bl->y,SO_ELECTRICWALK,NULL,0) == NULL
-                    && map_find_skill_unit_oncell(bl,bl->x,bl->y,SO_FIREWALK,NULL,0) == NULL
-                    && skill_unitsetting(bl,sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2,x0, y0,0)) {
-                    sc->data[SC_PROPERTYWALK]->val3++;
-                }
-
-
-            }
-            /* Guild Aura Moving */
-            if (bl->type == BL_PC && ((TBL_PC *)bl)->state.gmaster_flag) {
-                if (sc->data[SC_LEADERSHIP])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_LEADERSHIP]->val4), bl->m, x1-x0, y1-y0);
-                if (sc->data[SC_GLORYWOUNDS])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_GLORYWOUNDS]->val4), bl->m, x1-x0, y1-y0);
-                if (sc->data[SC_SOULCOLD])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_SOULCOLD]->val4), bl->m, x1-x0, y1-y0);
-                if (sc->data[SC_HAWKEYES])
-                    skill_unit_move_unit_group(skill_id2group(sc->data[SC_HAWKEYES]->val4), bl->m, x1-x0, y1-y0);
-            }
-        }
-    } else if (bl->type == BL_NPC)
-        npc_setcells((TBL_NPC *)bl);
-
-    return 0;
+	if (bl->type&BL_CHAR) {
+
+		skill_unit_move(bl,tick,3);
+
+		if( bl->type == BL_PC && ((TBL_PC*)bl)->shadowform_id ) {//Shadow Form Target Moving
+			struct block_list *d_bl;
+			if( (d_bl = map_id2bl(((TBL_PC*)bl)->shadowform_id)) == NULL || bl->m != d_bl->m || !check_distance_bl(bl,d_bl,10) ) {
+				if( d_bl )
+					status_change_end(d_bl,SC__SHADOWFORM,INVALID_TIMER);
+				((TBL_PC*)bl)->shadowform_id = 0;
+			}
+		}
+
+		if (sc && sc->count) {
+			if (sc->data[SC_DANCING])
+				skill_unit_move_unit_group(skill_id2group(sc->data[SC_DANCING]->val2), bl->m, x1-x0, y1-y0);
+			else {
+				if (sc->data[SC_CLOAKING])
+					skill_check_cloaking(bl, sc->data[SC_CLOAKING]);
+				if (sc->data[SC_WARM])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_WARM]->val4), bl->m, x1-x0, y1-y0);
+				if (sc->data[SC_BANDING])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_BANDING]->val4), bl->m, x1-x0, y1-y0);
+
+				if (sc->data[SC_NEUTRALBARRIER_MASTER])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_NEUTRALBARRIER_MASTER]->val2), bl->m, x1-x0, y1-y0);
+				else if (sc->data[SC_STEALTHFIELD_MASTER])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_STEALTHFIELD_MASTER]->val2), bl->m, x1-x0, y1-y0);
+
+				if( sc->data[SC__SHADOWFORM] ) {//Shadow Form Caster Moving
+					struct block_list *d_bl;
+					if( (d_bl = map_id2bl(sc->data[SC__SHADOWFORM]->val2)) == NULL || bl->m != d_bl->m || !check_distance_bl(bl,d_bl,10) )
+						status_change_end(bl,SC__SHADOWFORM,INVALID_TIMER);
+				}
+
+				if (sc->data[SC_PROPERTYWALK]
+					&& sc->data[SC_PROPERTYWALK]->val3 < skill_get_maxcount(sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2)
+					&& map_find_skill_unit_oncell(bl,bl->x,bl->y,SO_ELECTRICWALK,NULL,0) == NULL
+					&& map_find_skill_unit_oncell(bl,bl->x,bl->y,SO_FIREWALK,NULL,0) == NULL
+					&& skill_unitsetting(bl,sc->data[SC_PROPERTYWALK]->val1,sc->data[SC_PROPERTYWALK]->val2,x0, y0,0)) {
+						sc->data[SC_PROPERTYWALK]->val3++;
+				}
+
+
+			}
+			/* Guild Aura Moving */
+			if( bl->type == BL_PC && ((TBL_PC*)bl)->state.gmaster_flag ) {
+				if (sc->data[SC_LEADERSHIP])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_LEADERSHIP]->val4), bl->m, x1-x0, y1-y0);
+				if (sc->data[SC_GLORYWOUNDS])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_GLORYWOUNDS]->val4), bl->m, x1-x0, y1-y0);
+				if (sc->data[SC_SOULCOLD])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_SOULCOLD]->val4), bl->m, x1-x0, y1-y0);
+				if (sc->data[SC_HAWKEYES])
+					skill_unit_move_unit_group(skill_id2group(sc->data[SC_HAWKEYES]->val4), bl->m, x1-x0, y1-y0);
+			}
+		}
+	} else
+	if (bl->type == BL_NPC)
+		npc_setcells((TBL_NPC*)bl);
+
+	return 0;
 }
 
 /*==========================================
@@ -471,189 +477,190 @@ int map_moveblock(struct block_list *bl, int x1, int y1, unsigned int tick)
  *------------------------------------------*/
 int map_count_oncell(int m, int x, int y, int type)
 {
-    int bx,by;
-    struct block_list *bl;
-    int count = 0;
+	int bx,by;
+	struct block_list *bl;
+	int count = 0;
 
-    if (x < 0 || y < 0 || (x >= map[m].xs) || (y >= map[m].ys))
-        return 0;
+	if (x < 0 || y < 0 || (x >= map[m].xs) || (y >= map[m].ys))
+		return 0;
 
-    bx = x/BLOCK_SIZE;
-    by = y/BLOCK_SIZE;
+	bx = x/BLOCK_SIZE;
+	by = y/BLOCK_SIZE;
 
-    if (type&~BL_MOB)
-        for (bl = map[m].block[bx+by*map[m].bxs] ; bl != NULL ; bl = bl->next)
-            if (bl->x == x && bl->y == y && bl->type&type)
-                count++;
+	if (type&~BL_MOB)
+		for( bl = map[m].block[bx+by*map[m].bxs] ; bl != NULL ; bl = bl->next )
+			if(bl->x == x && bl->y == y && bl->type&type)
+				count++;
 
-    if (type&BL_MOB)
-        for (bl = map[m].block_mob[bx+by*map[m].bxs] ; bl != NULL ; bl = bl->next)
-            if (bl->x == x && bl->y == y)
-                count++;
+	if (type&BL_MOB)
+		for( bl = map[m].block_mob[bx+by*map[m].bxs] ; bl != NULL ; bl = bl->next )
+			if(bl->x == x && bl->y == y)
+				count++;
 
-    return count;
+	return count;
 }
 /*
  * 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 block_list *bl;
-    struct skill_unit *unit;
-    m = target->m;
+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 block_list *bl;
+	struct skill_unit *unit;
+	m = target->m;
 
-    if (x < 0 || y < 0 || (x >= map[m].xs) || (y >= map[m].ys))
-        return NULL;
+	if (x < 0 || y < 0 || (x >= map[m].xs) || (y >= map[m].ys))
+		return NULL;
 
-    bx = x/BLOCK_SIZE;
-    by = y/BLOCK_SIZE;
+	bx = x/BLOCK_SIZE;
+	by = y/BLOCK_SIZE;
 
-    for (bl = map[m].block[bx+by *map[m].bxs] ; bl != NULL ; bl = bl->next) {
-        if (bl->x != x || bl->y != y || bl->type != BL_SKILL)
-            continue;
+	for( bl = map[m].block[bx+by*map[m].bxs] ; bl != NULL ; bl = bl->next )
+	{
+		if (bl->x != x || bl->y != y || bl->type != BL_SKILL)
+			continue;
 
-        unit = (struct skill_unit *) bl;
-        if (unit == out_unit || !unit->alive || !unit->group || unit->group->skill_id != skill_id)
-            continue;
-        if (!(flag&1) || battle_check_target(&unit->bl,target,unit->group->target_flag) > 0)
-            return unit;
-    }
-    return NULL;
+		unit = (struct skill_unit *) bl;
+		if( unit == out_unit || !unit->alive || !unit->group || unit->group->skill_id != skill_id )
+			continue;
+		if( !(flag&1) || battle_check_target(&unit->bl,target,unit->group->target_flag) > 0 )
+			return unit;
+	}
+	return NULL;
 }
 
 /*==========================================
  * 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 bx, by, m;
-    int returnCount = 0;    //total sum of returned values of func() [Skotlex]
-    struct block_list *bl;
-    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);
-    x1 = min(center->x + range, map[ m ].xs - 1);
-    y1 = min(center->y + range, map[ m ].ys - 1);
-
-    if (type&~BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++) {
-                for (bl = map[m].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->type&type
-                        && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int type, ...)
+{
+	int bx, by, m;
+	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
+	struct block_list *bl;
+	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);
+	x1 = min(center->x + range, map[ m ].xs - 1);
+	y1 = min(center->y + range, map[ m ].ys - 1);
+
+	if ( type&~BL_MOB )
+		for ( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[m].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->type&type
+						&& bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
-
-    if (type&BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx=x0/BLOCK_SIZE; bx<=x1/BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+					  	&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
+	
+	if( type&BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for(bx=x0/BLOCK_SIZE;bx<=x1/BLOCK_SIZE;bx++) {
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
+						&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
 
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinrange: block count too many!\n");
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinrange: block count too many!\n");
 
-    map_freeblock_lock();
+	map_freeblock_lock();
 
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
 
-    map_freeblock_unlock();
+	map_freeblock_unlock();
 
-    bl_list_count = blockcount;
-    return returnCount; //[Skotlex]
+	bl_list_count = blockcount;
+	return returnCount;	//[Skotlex]
 }
 
 /*==========================================
  * 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 bx, by, m;
-    int returnCount = 0;    //total sum of returned values of func() [Skotlex]
-    struct block_list *bl;
-    int blockcount = bl_list_count, i;
-    int x0, x1, y0, y1;
-    va_list ap;
-
-    m = center->m;
-    if (m < 0)
-        return 0;
-
-    x0 = max(center->x-range, 0);
-    y0 = max(center->y-range, 0);
-    x1 = min(center->x+range, map[m].xs-1);
-    y1 = min(center->y+range, map[m].ys-1);
-
-    if (type&~BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->type&type
-                        && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block_list* center, int range, int type,...)
+{
+	int bx, by, m;
+	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
+	struct block_list *bl;
+	int blockcount = bl_list_count, i;
+	int x0, x1, y0, y1;
+	va_list ap;
+	
+	m = center->m;
+	if ( m < 0 )
+		return 0;
+
+	x0 = max(center->x-range, 0);
+	y0 = max(center->y-range, 0);
+	x1 = min(center->x+range, map[m].xs-1);
+	y1 = min(center->y+range, map[m].ys-1);
+
+	if ( type&~BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->type&type
+						&& bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
-    if (type&BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx=x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+						&& path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
+					  	&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
+	if( type&BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for( bx=x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
+						&& path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
+						&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
 
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinrange: block count too many!\n");
+	if( bl_list_count >= BL_LIST_MAX )
+			ShowWarning("map_foreachinrange: block count too many!\n");
 
-    map_freeblock_lock();
+	map_freeblock_lock();
 
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
 
-    map_freeblock_unlock();
+	map_freeblock_unlock();
 
-    bl_list_count = blockcount;
-    return returnCount; //[Skotlex]
+	bl_list_count = blockcount;
+	return returnCount;	//[Skotlex]
 }
 
 /*==========================================
@@ -661,175 +668,175 @@ int map_foreachinshootrange(int (*func)(struct block_list *,va_list),struct bloc
  * 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 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);
-    y1 = min(y1, map[ m ].ys - 1);
-    if (type&~BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++)
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++)
-                for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next)
-                    if (bl->type&type && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-
-    if (type&BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++)
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++)
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next)
-                    if (bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinarea: block count too many!\n");
-
-    map_freeblock_lock();
-
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
-
-    map_freeblock_unlock();
-
-    bl_list_count = blockcount;
-    return returnCount; //[Skotlex]
+int map_foreachinarea(int (*func)(struct block_list*,va_list), int m, int x0, int y0, int x1, int 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);
+	y1 = min(y1, map[ m ].ys - 1);
+	if ( type&~BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ )
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ )
+				for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next )
+					if( bl->type&type && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+
+	if( type&BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ )
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ )
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next )
+					if( bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinarea: block count too many!\n");
+
+	map_freeblock_lock();
+
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
+
+	map_freeblock_unlock();
+
+	bl_list_count = blockcount;
+	return returnCount;	//[Skotlex]
 }
 /*==========================================
  * 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 bx, by, m;
-    int returnCount = 0;    //total sum of returned values of func() [Skotlex]
-    struct block_list *bl;
-    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);
-    x1 = min(center->x + range, map[ m ].xs - 1);
-    y1 = min(center->y + range, map[ m ].ys - 1);
-
-    if (type&~BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->type&type
-                        && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int count, int type, ...)
+{
+	int bx, by, m;
+	int returnCount = 0;	//total sum of returned values of func() [Skotlex]
+	struct block_list *bl;
+	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);
+	x1 = min(center->x + range, map[ m ].xs - 1);
+	y1 = min(center->y + range, map[ m ].ys - 1);
+
+	if ( type&~BL_MOB )
+		for ( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->type&type
+						&& bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
-    if (type&BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++) {
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
+					  	&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
+	if( type&BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ ) {
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ ){
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1
 #ifdef CIRCULAR_AREA
-                        && check_distance_bl(center, bl, range)
+						&& check_distance_bl(center, bl, range)
 #endif
-                        && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-                }
-            }
-        }
-
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_forcountinrange: block count too many!\n");
-
-    map_freeblock_lock();
-
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-            if (count && returnCount >= count)
-                break;
-        }
-
-    map_freeblock_unlock();
-
-    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 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);
-    y1 = min(y1, map[ m ].ys - 1);
-
-    if (type&~BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++)
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++)
-                for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next)
-                    if (bl->type&type && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-
-    if (type&BL_MOB)
-        for (by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++)
-            for (bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++)
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next)
-                    if (bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX)
-                        bl_list[ bl_list_count++ ] = bl;
-
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinarea: block count too many!\n");
-
-    map_freeblock_lock();
-
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-            if (count && returnCount >= count)
-                break;
-        }
-
-    map_freeblock_unlock();
-
-    bl_list_count = blockcount;
-    return returnCount; //[Skotlex]
+						&& bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+				}
+			}
+		}
+
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_forcountinrange: block count too many!\n");
+
+	map_freeblock_lock();
+
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+			if( count && returnCount >= count )
+				break;
+		}
+
+	map_freeblock_unlock();
+
+	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 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);
+	y1 = min(y1, map[ m ].ys - 1);
+
+	if ( type&~BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ )
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ )
+				for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next )
+					if( bl->type&type && bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+
+	if( type&BL_MOB )
+		for( by = y0 / BLOCK_SIZE; by <= y1 / BLOCK_SIZE; by++ )
+			for( bx = x0 / BLOCK_SIZE; bx <= x1 / BLOCK_SIZE; bx++ )
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next )
+					if( bl->x >= x0 && bl->x <= x1 && bl->y >= y0 && bl->y <= y1 && bl_list_count < BL_LIST_MAX )
+						bl_list[ bl_list_count++ ] = bl;
+
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinarea: block count too many!\n");
+
+	map_freeblock_lock();
+
+	for( i = blockcount; i < bl_list_count; i++ )
+		if(bl_list[ i ]->prev) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+			if( count && returnCount >= count )
+				break;
+		}
+
+	map_freeblock_unlock();
+
+	bl_list_count = blockcount;
+	return returnCount;	//[Skotlex]
 }
 
 /*==========================================
@@ -837,390 +844,390 @@ int map_forcountinarea(int (*func)(struct block_list *,va_list), int m, int x0,
  * 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 bx, by, m;
-    int returnCount = 0;  //total sum of returned values of func() [Skotlex]
-    struct block_list *bl;
-    int blockcount = bl_list_count, i;
-    int x0, x1, y0, y1;
-    va_list ap;
-
-    if (!range) return 0;
-    if (!dx && !dy) return 0;   //No movement.
-
-    m = center->m;
-
-    x0 = center->x - range;
-    x1 = center->x + range;
-    y0 = center->y - range;
-    y1 = center->y + range;
-
-    if (x1 < x0)
-        swap(x0, x1);
-    if (y1 < y0)
-        swap(y0, y1);
-
-    if (dx == 0 || dy == 0) {
-        //Movement along one axis only.
-        if (dx == 0) {
-            if (dy < 0)  //Moving south
-                y0 = y1 + dy + 1;
-            else //North
-                y1 = y0 + dy - 1;
-        } else { //dy == 0
-            if (dx < 0)  //West
-                x0 = x1 + dx + 1;
-            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) {
-                    for (bl = map[m].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                        if (bl->type&type &&
-                            bl->x >= x0 && bl->x <= x1 &&
-                            bl->y >= y0 && bl->y <= y1 &&
-                            bl_list_count < BL_LIST_MAX)
-                            bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-                if (type&BL_MOB) {
-                    for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                        if (bl->x >= x0 && bl->x <= x1 &&
-                            bl->y >= y0 && bl->y <= y1 &&
-                            bl_list_count < BL_LIST_MAX)
-                            bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-            }
-        }
-    } 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) {
-                    for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                        if (bl->type&type &&
-                            bl->x >= x0 && bl->x <= x1 &&
-                            bl->y >= y0 && bl->y <= y1 &&
-                            bl_list_count < BL_LIST_MAX)
-                            if ((dx > 0 && bl->x < x0 + dx) ||
-                                (dx < 0 && bl->x > x1 + dx) ||
-                                (dy > 0 && bl->y < y0 + dy) ||
-                                (dy < 0 && bl->y > y1 + dy))
-                                bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-                if (type&BL_MOB) {
-                    for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                        if (bl->x >= x0 && bl->x <= x1 &&
-                            bl->y >= y0 && bl->y <= y1 &&
-                            bl_list_count < BL_LIST_MAX)
-                            if ((dx > 0 && bl->x < x0 + dx) ||
-                                (dx < 0 && bl->x > x1 + dx) ||
-                                (dy > 0 && bl->y < y0 + dy) ||
-                                (dy < 0 && bl->y > y1 + dy))
-                                bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-            }
-        }
-
-    }
-
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinmovearea: block count too many!\n");
-
-    map_freeblock_lock();   // Prohibit the release from memory
-
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
-
-    map_freeblock_unlock(); // Allow Free
-
-    bl_list_count = blockcount;
-    return returnCount;
-}
-
-// -- moonsoul  (added map_foreachincell which is a rework of map_foreachinarea but
-//           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_foreachinmovearea(int (*func)(struct block_list*,va_list), struct block_list* center, int range, int dx, int dy, int type, ...)
+{
+	int bx, by, m;
+	int returnCount = 0;  //total sum of returned values of func() [Skotlex]
+	struct block_list *bl;
+	int blockcount = bl_list_count, i;
+	int x0, x1, y0, y1;
+	va_list ap;
+
+	if ( !range ) return 0;
+	if ( !dx && !dy ) return 0; //No movement.
+	
+	m = center->m;
+
+	x0 = center->x - range;
+	x1 = center->x + range;
+	y0 = center->y - range;
+	y1 = center->y + range;
+
+	if ( x1 < x0 )
+		swap(x0, x1);
+	if ( y1 < y0 )
+		swap(y0, y1);
+	
+	if( dx == 0 || dy == 0 ) {
+		//Movement along one axis only.
+		if( dx == 0 ){
+			if( dy < 0 ) //Moving south
+				y0 = y1 + dy + 1;
+			else //North
+				y1 = y0 + dy - 1;
+		} else { //dy == 0
+			if( dx < 0 ) //West
+				x0 = x1 + dx + 1;
+			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 ) {
+					for( bl = map[m].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+						if( bl->type&type &&
+							bl->x >= x0 && bl->x <= x1 &&
+							bl->y >= y0 && bl->y <= y1 &&
+							bl_list_count < BL_LIST_MAX )
+							bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+				if ( type&BL_MOB ) {
+					for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+						if( bl->x >= x0 && bl->x <= x1 &&
+							bl->y >= y0 && bl->y <= y1 &&
+							bl_list_count < BL_LIST_MAX )
+							bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+			}
+		}
+	} 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 ) {
+					for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+						if( bl->type&type &&
+							bl->x >= x0 && bl->x <= x1 &&
+							bl->y >= y0 && bl->y <= y1 &&
+							bl_list_count < BL_LIST_MAX )
+						if( ( dx > 0 && bl->x < x0 + dx) ||
+							( dx < 0 && bl->x > x1 + dx) ||
+							( dy > 0 && bl->y < y0 + dy) ||
+							( dy < 0 && bl->y > y1 + dy) )
+							bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+				if ( type&BL_MOB ) {
+					for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+						if( bl->x >= x0 && bl->x <= x1 &&
+							bl->y >= y0 && bl->y <= y1 &&
+							bl_list_count < BL_LIST_MAX)
+						if( ( dx > 0 && bl->x < x0 + dx) ||
+							( dx < 0 && bl->x > x1 + dx) ||
+							( dy > 0 && bl->y < y0 + dy) ||
+							( dy < 0 && bl->y > y1 + dy) )
+							bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+			}
+		}
+
+	}
+
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinmovearea: block count too many!\n");
+
+	map_freeblock_lock();	// Prohibit the release from memory
+
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
+
+	map_freeblock_unlock();	// Allow Free
+
+	bl_list_count = blockcount;
+	return returnCount;
+}
+
+// -- moonsoul	(added map_foreachincell which is a rework of map_foreachinarea but
+//			 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), int m, int x, int y, 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;
+	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 (x < 0 || y < 0 || x >= map[ m ].xs || y >= map[ m ].ys) return 0;
+	if ( x < 0 || y < 0 || x >= map[ m ].xs || y >= map[ m ].ys ) return 0;
 
-    by = y / BLOCK_SIZE;
-    bx = x / BLOCK_SIZE;
+	by = y / BLOCK_SIZE;
+	bx = x / BLOCK_SIZE;
 
-    if (type&~BL_MOB)
-        for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next)
-            if (bl->type&type && bl->x == x && bl->y == y && bl_list_count < BL_LIST_MAX)
-                bl_list[ bl_list_count++ ] = bl;
-    if (type&BL_MOB)
-        for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs]; bl != NULL; bl = bl->next)
-            if (bl->x == x && bl->y == y && bl_list_count < BL_LIST_MAX)
-                bl_list[ bl_list_count++ ] = bl;
+	if( type&~BL_MOB )
+		for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next )
+			if( bl->type&type && bl->x == x && bl->y == y && bl_list_count < BL_LIST_MAX )
+				bl_list[ bl_list_count++ ] = bl;
+	if( type&BL_MOB )
+		for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs]; bl != NULL; bl = bl->next )
+			if( bl->x == x && bl->y == y && bl_list_count < BL_LIST_MAX)
+				bl_list[ bl_list_count++ ] = bl;
 
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachincell: block count too many!\n");
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachincell: block count too many!\n");
 
-    map_freeblock_lock();
+	map_freeblock_lock();
 
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
 
-    map_freeblock_unlock();
+	map_freeblock_unlock();
 
-    bl_list_count = blockcount;
-    return returnCount;
+	bl_list_count = blockcount;
+	return returnCount;
 }
 
 /*============================================================
 * 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 returnCount = 0;  //total sum of returned values of func() [Skotlex]
-    //////////////////////////////////////////////////////////////
-    //
-    // sharp shooting 3 [Skotlex]
-    //
-    //////////////////////////////////////////////////////////////
-    // problem:
-    // Same as Sharp Shooting 1. Hits all targets within range of
-    // the line.
-    // (t1,t2 t3 and t4 get hit)
-    //
-    //     target 1
-    //      x t4
-    //     t2
-    // t3 x
-    //   x
-    //  S
-    //////////////////////////////////////////////////////////////
-    // Methodology:
-    // My trigonometrics and math are a little rusty... so the approach I am writing
-    // here is basicly do a double for to check for all targets in the square that
-    // contains the initial and final positions (area range increased to match the
-    // radius given), then for each object to test, calculate the distance to the
-    // path and include it if the range fits and the target is in the line (0<k<1,
-    // as they call it).
-    // The implementation I took as reference is found at
-    // http://astronomy.swin.edu.au/~pbourke/geometry/pointline/
-    // (they have a link to a C implementation, too)
-    // This approach is a lot like #2 commented on this function, which I have no
-    // idea why it was commented. I won't use doubles/floats, but pure int math for
-    // speed purposes. The range considered is always the same no matter how
-    // close/far the target is because that's how SharpShooting works currently in
-    // kRO.
-
-    //Generic map_foreach* variables.
-    int i, blockcount = bl_list_count;
-    struct block_list *bl;
-    int bx, by;
-    //method specific variables
-    int magnitude2, len_limit; //The square of the magnitude
-    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 ) ) )
-
-    if (m < 0)
-        return 0;
-
-    len_limit = magnitude2 = MAGNITUDE2(x0, y0, x1, y1);
-    if (magnitude2 < 1)   //Same begin and ending point, can't trace path.
-        return 0;
-
-    if (length) {   //Adjust final position to fit in the given area.
-        //TODO: Find an alternate method which does not requires a square root calculation.
-        k = (int)sqrt((float)magnitude2);
-        mx1 = x0 + (x1 - x0) * length / k;
-        my1 = y0 + (y1 - y0) * length / k;
-        len_limit = MAGNITUDE2(x0, y0, mx1, my1);
-    }
-    //Expand target area to cover range.
-    if (mx0 > mx1) {
-        mx0 += range;
-        mx1 -= range;
-    } else {
-        mx0 -= range;
-        mx1 += range;
-    }
-    if (my0 > my1) {
-        my0 += range;
-        my1 -= range;
-    } else {
-        my0 -= range;
-        my1 += range;
-    }
-
-    //The two fors assume mx0 < mx1 && my0 < my1
-    if (mx0 > mx1)
-        swap(mx0, mx1);
-    if (my0 > my1)
-        swap(my0, my1);
-
-    mx0 = max(mx0, 0);
-    my0 = max(my0, 0);
-    mx1 = min(mx1, map[ m ].xs - 1);
-    my1 = min(my1, map[ m ].ys - 1);
-
-    range *= range << 8; //Values are shifted later on for higher precision using int math.
-
-    if (type&~BL_MOB)
-        for (by = my0 / BLOCK_SIZE; by <= my1 / BLOCK_SIZE; by++) {
-            for (bx = mx0 / BLOCK_SIZE; bx <= mx1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->prev && bl->type&type && bl_list_count < BL_LIST_MAX) {
-                        xi = bl->x;
-                        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;
-
-                        if (k > magnitude2 && !path_search_long(NULL, m, x0, y0, xi, yi, CELL_CHKWALL))
-                            continue; //Targets beyond the initial ending point need the wall check.
-
-                        //All these shifts are to increase the precision of the intersection point and distance considering how it's
-                        //int math.
-                        k  = (k << 4) / magnitude2;   //k will be between 1~16 instead of 0~1
-                        xi <<= 4;
-                        yi <<= 4;
-                        xu = (x0 << 4) + k * (x1 - x0);
-                        yu = (y0 << 4) + k * (y1 - y0);
-                        k  = MAGNITUDE2(xi, yi, xu, yu);
-
-                        //If all dot coordinates were <<4 the square of the magnitude is <<8
-                        if (k > range)
-                            continue;
-
-                        bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-            }
-        }
-    if (type&BL_MOB)
-        for (by = my0 / BLOCK_SIZE; by <= my1 / BLOCK_SIZE; by++) {
-            for (bx = mx0 / BLOCK_SIZE; bx <= mx1 / BLOCK_SIZE; bx++) {
-                for (bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next) {
-                    if (bl->prev && bl_list_count < BL_LIST_MAX) {
-                        xi = bl->x;
-                        yi = bl->y;
-                        k = (xi - x0) * (x1 - x0) + (yi - y0) * (y1 - y0);
-
-                        if (k < 0 || k > len_limit)
-                            continue;
-
-                        if (k > magnitude2 && !path_search_long(NULL, m, x0, y0, xi, yi, CELL_CHKWALL))
-                            continue; //Targets beyond the initial ending point need the wall check.
-
-                        k  = (k << 4) / magnitude2;   //k will be between 1~16 instead of 0~1
-                        xi <<= 4;
-                        yi <<= 4;
-                        xu = (x0 << 4) + k * (x1 - x0);
-                        yu = (y0 << 4) + k * (y1 - y0);
-                        k  = MAGNITUDE2(xi, yi, xu, yu);
-
-                        //If all dot coordinates were <<4 the square of the magnitude is <<8
-                        if (k > range)
-                            continue;
-
-                        bl_list[ bl_list_count++ ] = bl;
-                    }
-                }
-            }
-        }
-
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinpath: block count too many!\n");
-
-    map_freeblock_lock();
-
-    for (i = blockcount; i < bl_list_count; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
-
-    map_freeblock_unlock();
-
-    bl_list_count = blockcount;
-    return returnCount; //[Skotlex]
+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 returnCount = 0;  //total sum of returned values of func() [Skotlex]
+//////////////////////////////////////////////////////////////
+//
+// sharp shooting 3 [Skotlex]
+//
+//////////////////////////////////////////////////////////////
+// problem:
+// Same as Sharp Shooting 1. Hits all targets within range of
+// the line.
+// (t1,t2 t3 and t4 get hit)
+//
+//     target 1
+//      x t4
+//     t2
+// t3 x
+//   x
+//  S
+//////////////////////////////////////////////////////////////
+// Methodology:
+// My trigonometrics and math are a little rusty... so the approach I am writing
+// here is basicly do a double for to check for all targets in the square that
+// contains the initial and final positions (area range increased to match the
+// radius given), then for each object to test, calculate the distance to the
+// path and include it if the range fits and the target is in the line (0<k<1,
+// as they call it).
+// The implementation I took as reference is found at
+// http://astronomy.swin.edu.au/~pbourke/geometry/pointline/
+// (they have a link to a C implementation, too)
+// This approach is a lot like #2 commented on this function, which I have no
+// idea why it was commented. I won't use doubles/floats, but pure int math for
+// speed purposes. The range considered is always the same no matter how
+// close/far the target is because that's how SharpShooting works currently in
+// kRO.
+
+	//Generic map_foreach* variables.
+	int i, blockcount = bl_list_count;
+	struct block_list *bl;
+	int bx, by;
+	//method specific variables
+	int magnitude2, len_limit; //The square of the magnitude
+	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 ) ) )
+
+	if ( m < 0 )
+		return 0;
+
+	len_limit = magnitude2 = MAGNITUDE2(x0, y0, x1, y1);
+	if ( magnitude2 < 1 ) //Same begin and ending point, can't trace path.
+		return 0;
+
+	if ( length ) { //Adjust final position to fit in the given area.
+		//TODO: Find an alternate method which does not requires a square root calculation.
+		k = (int)sqrt((float)magnitude2);
+		mx1 = x0 + (x1 - x0) * length / k;
+		my1 = y0 + (y1 - y0) * length / k;
+		len_limit = MAGNITUDE2(x0, y0, mx1, my1);
+	}
+	//Expand target area to cover range.
+	if ( mx0 > mx1 ) {
+		mx0 += range;
+		mx1 -= range;
+	} else {
+		mx0 -= range;
+		mx1 += range;
+	}
+	if (my0 > my1) {
+		my0 += range;
+		my1 -= range;
+	} else {
+		my0 -= range;
+		my1 += range;
+	}
+
+	//The two fors assume mx0 < mx1 && my0 < my1
+	if ( mx0 > mx1 )
+		swap(mx0, mx1);
+	if ( my0 > my1 )
+		swap(my0, my1);
+
+	mx0 = max(mx0, 0);
+	my0 = max(my0, 0);
+	mx1 = min(mx1, map[ m ].xs - 1);
+	my1 = min(my1, map[ m ].ys - 1);
+
+	range *= range << 8; //Values are shifted later on for higher precision using int math.
+
+	if ( type&~BL_MOB )
+		for ( by = my0 / BLOCK_SIZE; by <= my1 / BLOCK_SIZE; by++ ) {
+			for( bx = mx0 / BLOCK_SIZE; bx <= mx1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[ m ].block[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->prev && bl->type&type && bl_list_count < BL_LIST_MAX ) {
+						xi = bl->x;
+						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;
+
+						if ( k > magnitude2 && !path_search_long(NULL, m, x0, y0, xi, yi, CELL_CHKWALL) )
+							continue; //Targets beyond the initial ending point need the wall check.
+
+						//All these shifts are to increase the precision of the intersection point and distance considering how it's
+						//int math.
+						k  = ( k << 4 ) / magnitude2; //k will be between 1~16 instead of 0~1
+						xi <<= 4;
+						yi <<= 4;
+						xu = ( x0 << 4 ) + k * ( x1 - x0 );
+						yu = ( y0 << 4 ) + k * ( y1 - y0 );
+						k  = MAGNITUDE2(xi, yi, xu, yu);
+
+						//If all dot coordinates were <<4 the square of the magnitude is <<8
+						if ( k > range )
+							continue;
+
+						bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+			}
+		}
+	 if( type&BL_MOB )
+		for( by = my0 / BLOCK_SIZE; by <= my1 / BLOCK_SIZE; by++ ) {
+			for( bx = mx0 / BLOCK_SIZE; bx <= mx1 / BLOCK_SIZE; bx++ ) {
+				for( bl = map[ m ].block_mob[ bx + by * map[ m ].bxs ]; bl != NULL; bl = bl->next ) {
+					if( bl->prev && bl_list_count < BL_LIST_MAX ) {
+						xi = bl->x;
+						yi = bl->y;
+						k = ( xi - x0 ) * ( x1 - x0 ) + ( yi - y0 ) * ( y1 - y0 );
+						
+						if ( k < 0 || k > len_limit )
+							continue;
+
+						if ( k > magnitude2 && !path_search_long(NULL, m, x0, y0, xi, yi, CELL_CHKWALL) )
+							continue; //Targets beyond the initial ending point need the wall check.
+
+						k  = ( k << 4 ) / magnitude2; //k will be between 1~16 instead of 0~1
+						xi <<= 4;
+						yi <<= 4;
+						xu = ( x0 << 4 ) + k * ( x1 - x0 );
+						yu = ( y0 << 4 ) + k * ( y1 - y0 );
+						k  = MAGNITUDE2(xi, yi, xu, yu);
+
+						//If all dot coordinates were <<4 the square of the magnitude is <<8
+						if ( k > range )
+							continue;
+
+						bl_list[ bl_list_count++ ] = bl;
+					}
+				}
+			}
+		}
+
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinpath: block count too many!\n");
+
+	map_freeblock_lock();
+
+	for( i = blockcount; i < bl_list_count; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
+
+	map_freeblock_unlock();
+
+	bl_list_count = blockcount;
+	return returnCount;	//[Skotlex]
 
 }
 
 // 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), int 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;
+	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)
-        for (b = 0; b < bsize; b++)
-            for (bl = map[ m ].block[ b ]; bl != NULL; bl = bl->next)
-                if (bl->type&type && bl_list_count < BL_LIST_MAX)
-                    bl_list[ bl_list_count++ ] = bl;
+	if( type&~BL_MOB )
+		for( b = 0; b < bsize; b++ )
+			for( bl = map[ m ].block[ b ]; bl != NULL; bl = bl->next )
+				if( bl->type&type && bl_list_count < BL_LIST_MAX )
+					bl_list[ bl_list_count++ ] = bl;
 
-    if (type&BL_MOB)
-        for (b = 0; b < bsize; b++)
-            for (bl = map[ m ].block_mob[ b ]; bl != NULL; bl = bl->next)
-                if (bl_list_count < BL_LIST_MAX)
-                    bl_list[ bl_list_count++ ] = bl;
+	if( type&BL_MOB )
+		for( b = 0; b < bsize; b++ )
+			for( bl = map[ m ].block_mob[ b ]; bl != NULL; bl = bl->next )
+				if( bl_list_count < BL_LIST_MAX )
+					bl_list[ bl_list_count++ ] = bl;
 
-    if (bl_list_count >= BL_LIST_MAX)
-        ShowWarning("map_foreachinmap: block count too many!\n");
+	if( bl_list_count >= BL_LIST_MAX )
+		ShowWarning("map_foreachinmap: block count too many!\n");
 
-    map_freeblock_lock();
+	map_freeblock_lock();
 
-    for (i = blockcount; i < bl_list_count ; i++)
-        if (bl_list[ i ]->prev) {  //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
-            va_start(ap, type);
-            returnCount += func(bl_list[ i ], ap);
-            va_end(ap);
-        }
+	for( i = blockcount; i < bl_list_count ; i++ )
+		if( bl_list[ i ]->prev ) { //func() may delete this bl_list[] slot, checking for prev ensures it wasnt queued for deletion.
+			va_start(ap, type);
+			returnCount += func(bl_list[ i ], ap);
+			va_end(ap);
+		}
 
-    map_freeblock_unlock();
+	map_freeblock_unlock();
 
-    bl_list_count = blockcount;
-    return returnCount;
+	bl_list_count = blockcount;
+	return returnCount;
 }
 
 
@@ -1229,30 +1236,30 @@ int map_foreachinmap(int (*func)(struct block_list *,va_list), int m, int type,.
 /// @return The new object id
 int map_get_new_object_id(void)
 {
-    static int last_object_id = MIN_FLOORITEM - 1;
-    int i;
+	static int last_object_id = MIN_FLOORITEM - 1;
+	int i;
 
-    // find a free id
-    i = last_object_id + 1;
-    while (i != last_object_id) {
-        if (i == MAX_FLOORITEM)
-            i = MIN_FLOORITEM;
+	// find a free id
+	i = last_object_id + 1;
+	while( i != last_object_id ) {
+		if( i == MAX_FLOORITEM )
+			i = MIN_FLOORITEM;
 
-        if (!idb_exists(id_db, i))
-            break;
+		if( !idb_exists(id_db, i) )
+			break;
 
-        ++i;
-    }
+		++i;
+	}
 
-    if (i == last_object_id) {
-        ShowError("map_addobject: no free object id!\n");
-        return 0;
-    }
+	if( i == last_object_id ) {
+		ShowError("map_addobject: no free object id!\n");
+		return 0;
+	}
 
-    // update cursor
-    last_object_id = i;
+	// update cursor
+	last_object_id = i;
 
-    return i;
+	return i;
 }
 
 /*==========================================
@@ -1261,38 +1268,37 @@ int map_get_new_object_id(void)
  *------------------------------------------*/
 int map_clearflooritem_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
-    struct flooritem_data *fitem = (struct flooritem_data *)idb_get(id_db, id);
+	struct flooritem_data* fitem = (struct flooritem_data*)idb_get(id_db, id);
 
-    if (fitem == NULL || fitem->bl.type != BL_ITEM || (fitem->cleartimer != tid)) {
-        ShowError("map_clearflooritem_timer : error\n");
-        return 1;
-    }
+	if (fitem == NULL || fitem->bl.type != BL_ITEM || (fitem->cleartimer != tid)) {
+		ShowError("map_clearflooritem_timer : error\n");
+		return 1;
+	}
 
 
-    if (search_petDB_index(fitem->item_data.nameid, PET_EGG) >= 0)
-        intif_delete_petdata(MakeDWord(fitem->item_data.card[1], fitem->item_data.card[2]));
+	if (search_petDB_index(fitem->item_data.nameid, PET_EGG) >= 0)
+		intif_delete_petdata(MakeDWord(fitem->item_data.card[1], fitem->item_data.card[2]));
 
-    clif_clearflooritem(fitem, 0);
-    map_deliddb(&fitem->bl);
-    map_delblock(&fitem->bl);
-    map_freeblock(&fitem->bl);
-    return 0;
+	clif_clearflooritem(fitem, 0);
+	map_deliddb(&fitem->bl);
+	map_delblock(&fitem->bl);
+	map_freeblock(&fitem->bl);
+	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);
-    map_freeblock(&fitem->bl);
+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);
+	map_freeblock(&fitem->bl);
 }
 
 /*==========================================
@@ -1300,38 +1306,37 @@ 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 free_cell,i,j;
-    int free_cells[9][2];
-
-    for (free_cell=0,i=-1; i<=1; i++) {
-        if (i+*y<0 || i+*y>=map[m].ys)
-            continue;
-        for (j=-1; j<=1; j++) {
-            if (j+*x<0 || j+*x>=map[m].xs)
-                continue;
-            if (map_getcell(m,j+*x,i+*y,CELL_CHKNOPASS) && !map_getcell(m,j+*x,i+*y,CELL_CHKICEWALL))
-                continue;
-            //Avoid item stacking to prevent against exploits. [Skotlex]
-            if (stack && map_count_oncell(m,j+*x,i+*y, BL_ITEM) > stack)
-                continue;
-            free_cells[free_cell][0] = j+*x;
-            free_cells[free_cell++][1] = i+*y;
-        }
-    }
-    if (free_cell==0)
-        return 0;
-    free_cell = rnd()%free_cell;
-    *x = free_cells[free_cell][0];
-    *y = free_cells[free_cell][1];
-    return 1;
+int map_searchrandfreecell(int m,int *x,int *y,int stack) {
+	int free_cell,i,j;
+	int free_cells[9][2];
+
+	for(free_cell=0,i=-1;i<=1;i++){
+		if(i+*y<0 || i+*y>=map[m].ys)
+			continue;
+		for(j=-1;j<=1;j++){
+			if(j+*x<0 || j+*x>=map[m].xs)
+				continue;
+			if(map_getcell(m,j+*x,i+*y,CELL_CHKNOPASS) && !map_getcell(m,j+*x,i+*y,CELL_CHKICEWALL))
+				continue;
+			//Avoid item stacking to prevent against exploits. [Skotlex]
+			if(stack && map_count_oncell(m,j+*x,i+*y, BL_ITEM) > stack)
+				continue;
+			free_cells[free_cell][0] = j+*x;
+			free_cells[free_cell++][1] = i+*y;
+		}
+	}
+	if(free_cell==0)
+		return 0;
+	free_cell = rnd()%free_cell;
+	*x = free_cells[free_cell][0];
+	*y = free_cells[free_cell][1];
+	return 1;
 }
 
 
 static int map_count_sub(struct block_list *bl,va_list ap)
 {
-    return 1;
+	return 1;
 }
 
 /*==========================================
@@ -1348,64 +1353,66 @@ static int map_count_sub(struct block_list *bl,va_list ap)
  *------------------------------------------*/
 int map_search_freecell(struct block_list *src, int m, short *x,short *y, int rx, int ry, int flag)
 {
-    int tries, spawn=0;
-    int bx, by;
-    int rx2 = 2*rx+1;
-    int ry2 = 2*ry+1;
-
-    if (!src && (!(flag&1) || flag&2)) {
-        ShowDebug("map_search_freecell: Incorrect usage! When src is NULL, flag has to be &1 and can't have &2\n");
-        return 0;
-    }
-
-    if (flag&1) {
-        bx = *x;
-        by = *y;
-    } else {
-        bx = src->x;
-        by = src->y;
-        m = src->m;
-    }
-    if (!rx && !ry) {
-        //No range? Return the target cell then....
-        *x = bx;
-        *y = by;
-        return map_getcell(m,*x,*y,CELL_CHKREACH);
-    }
-
-    if (rx >= 0 && ry >= 0) {
-        tries = rx2*ry2;
-        if (tries > 100) tries = 100;
-    } else {
-        tries = map[m].xs*map[m].ys;
-        if (tries > 500) tries = 500;
-    }
-
-    while (tries--) {
-        *x = (rx >= 0)?(rnd()%rx2-rx+bx):(rnd()%(map[m].xs-2)+1);
-        *y = (ry >= 0)?(rnd()%ry2-ry+by):(rnd()%(map[m].ys-2)+1);
-
-        if (*x == bx && *y == by)
-            continue; //Avoid picking the same target tile.
-
-        if (map_getcell(m,*x,*y,CELL_CHKREACH)) {
-            if (flag&2 && !unit_can_reach_pos(src, *x, *y, 1))
-                continue;
-            if (flag&4) {
-                if (spawn >= 100) return 0; //Limit of retries reached.
-                if (spawn++ < battle_config.no_spawn_on_player &&
-                    map_foreachinarea(map_count_sub, m,
-                                      *x-AREA_SIZE, *y-AREA_SIZE,
-                                      *x+AREA_SIZE, *y+AREA_SIZE, BL_PC)
-                   )
-                    continue;
-            }
-            return 1;
-        }
-    }
-    *x = bx;
-    *y = by;
-    return 0;
+	int tries, spawn=0;
+	int bx, by;
+	int rx2 = 2*rx+1;
+	int ry2 = 2*ry+1;
+
+	if( !src && (!(flag&1) || flag&2) )
+	{
+		ShowDebug("map_search_freecell: Incorrect usage! When src is NULL, flag has to be &1 and can't have &2\n");
+		return 0;
+	}
+
+	if (flag&1) {
+		bx = *x;
+		by = *y;
+	} else {
+		bx = src->x;
+		by = src->y;
+		m = src->m;
+	}
+	if (!rx && !ry) {
+		//No range? Return the target cell then....
+		*x = bx;
+		*y = by;
+		return map_getcell(m,*x,*y,CELL_CHKREACH);
+	}
+
+	if (rx >= 0 && ry >= 0) {
+		tries = rx2*ry2;
+		if (tries > 100) tries = 100;
+	} else {
+		tries = map[m].xs*map[m].ys;
+		if (tries > 500) tries = 500;
+	}
+
+	while(tries--) {
+		*x = (rx >= 0)?(rnd()%rx2-rx+bx):(rnd()%(map[m].xs-2)+1);
+		*y = (ry >= 0)?(rnd()%ry2-ry+by):(rnd()%(map[m].ys-2)+1);
+
+		if (*x == bx && *y == by)
+			continue; //Avoid picking the same target tile.
+
+		if (map_getcell(m,*x,*y,CELL_CHKREACH))
+		{
+			if(flag&2 && !unit_can_reach_pos(src, *x, *y, 1))
+				continue;
+			if(flag&4) {
+				if (spawn >= 100) return 0; //Limit of retries reached.
+				if (spawn++ < battle_config.no_spawn_on_player &&
+					map_foreachinarea(map_count_sub, m,
+						*x-AREA_SIZE, *y-AREA_SIZE,
+					  	*x+AREA_SIZE, *y+AREA_SIZE, BL_PC)
+				)
+				continue;
+			}
+			return 1;
+		}
+	}
+	*x = bx;
+	*y = by;
+	return 0;
 }
 
 /*==========================================
@@ -1419,45 +1426,45 @@ int map_search_freecell(struct block_list *src, int m, short *x,short *y, int rx
  *------------------------------------------*/
 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 r;
-    struct flooritem_data *fitem=NULL;
+	int r;
+	struct flooritem_data *fitem=NULL;
 
-    nullpo_ret(item_data);
+	nullpo_ret(item_data);
 
-    if (!map_searchrandfreecell(m,&x,&y,flags&2?1:0))
-        return 0;
-    r=rnd();
+	if(!map_searchrandfreecell(m,&x,&y,flags&2?1:0))
+		return 0;
+	r=rnd();
 
-    CREATE(fitem, struct flooritem_data, 1);
-    fitem->bl.type=BL_ITEM;
-    fitem->bl.prev = fitem->bl.next = NULL;
-    fitem->bl.m=m;
-    fitem->bl.x=x;
-    fitem->bl.y=y;
-    fitem->bl.id = map_get_new_object_id();
-    if (fitem->bl.id==0) {
-        aFree(fitem);
-        return 0;
-    }
+	CREATE(fitem, struct flooritem_data, 1);
+	fitem->bl.type=BL_ITEM;
+	fitem->bl.prev = fitem->bl.next = NULL;
+	fitem->bl.m=m;
+	fitem->bl.x=x;
+	fitem->bl.y=y;
+	fitem->bl.id = map_get_new_object_id();
+	if(fitem->bl.id==0){
+		aFree(fitem);
+		return 0;
+	}
 
-    fitem->first_get_charid = first_charid;
-    fitem->first_get_tick = gettick() + (flags&1 ? battle_config.mvp_item_first_get_time : battle_config.item_first_get_time);
-    fitem->second_get_charid = second_charid;
-    fitem->second_get_tick = fitem->first_get_tick + (flags&1 ? battle_config.mvp_item_second_get_time : battle_config.item_second_get_time);
-    fitem->third_get_charid = third_charid;
-    fitem->third_get_tick = fitem->second_get_tick + (flags&1 ? battle_config.mvp_item_third_get_time : battle_config.item_third_get_time);
+	fitem->first_get_charid = first_charid;
+	fitem->first_get_tick = gettick() + (flags&1 ? battle_config.mvp_item_first_get_time : battle_config.item_first_get_time);
+	fitem->second_get_charid = second_charid;
+	fitem->second_get_tick = fitem->first_get_tick + (flags&1 ? battle_config.mvp_item_second_get_time : battle_config.item_second_get_time);
+	fitem->third_get_charid = third_charid;
+	fitem->third_get_tick = fitem->second_get_tick + (flags&1 ? battle_config.mvp_item_third_get_time : battle_config.item_third_get_time);
 
-    memcpy(&fitem->item_data,item_data,sizeof(*item_data));
-    fitem->item_data.amount=amount;
-    fitem->subx=(r&3)*3+3;
-    fitem->suby=((r>>2)&3)*3+3;
-    fitem->cleartimer=add_timer(gettick()+battle_config.flooritem_lifetime,map_clearflooritem_timer,fitem->bl.id,0);
+	memcpy(&fitem->item_data,item_data,sizeof(*item_data));
+	fitem->item_data.amount=amount;
+	fitem->subx=(r&3)*3+3;
+	fitem->suby=((r>>2)&3)*3+3;
+	fitem->cleartimer=add_timer(gettick()+battle_config.flooritem_lifetime,map_clearflooritem_timer,fitem->bl.id,0);
 
-    map_addiddb(&fitem->bl);
-    map_addblock(&fitem->bl);
-    clif_dropflooritem(fitem);
+	map_addiddb(&fitem->bl);
+	map_addblock(&fitem->bl);
+	clif_dropflooritem(fitem);
 
-    return fitem->bl.id;
+	return fitem->bl.id;
 }
 
 /**
@@ -1465,85 +1472,89 @@ int map_addflooritem(struct item *item_data,int amount,int m,int x,int y,int fir
  */
 static DBData create_charid2nick(DBKey key, va_list args)
 {
-    struct charid2nick *p;
-    CREATE(p, struct charid2nick, 1);
-    return db_ptr2data(p);
+	struct charid2nick *p;
+	CREATE(p, struct charid2nick, 1);
+	return db_ptr2data(p);
 }
 
 /// Adds(or replaces) the nick of charid to nick_db and fullfils pending requests.
 /// Does nothing if the character is online.
-void map_addnickdb(int charid, const char *nick)
+void map_addnickdb(int charid, const char* nick)
 {
-    struct charid2nick *p;
-    struct charid_request *req;
-    struct map_session_data *sd;
+	struct charid2nick* p;
+	struct charid_request* req;
+	struct map_session_data* sd;
 
-    if (map_charid2sd(charid))
-        return;// already online
+	if( map_charid2sd(charid) )
+		return;// already online
 
-    p = idb_ensure(nick_db, charid, create_charid2nick);
-    safestrncpy(p->nick, nick, sizeof(p->nick));
+	p = idb_ensure(nick_db, charid, create_charid2nick);
+	safestrncpy(p->nick, nick, sizeof(p->nick));
 
-    while (p->requests) {
-        req = p->requests;
-        p->requests = req->next;
-        sd = map_charid2sd(req->charid);
-        if (sd)
-            clif_solved_charname(sd->fd, charid, p->nick);
-        aFree(req);
-    }
+	while( p->requests )
+	{
+		req = p->requests;
+		p->requests = req->next;
+		sd = map_charid2sd(req->charid);
+		if( sd )
+			clif_solved_charname(sd->fd, charid, p->nick);
+		aFree(req);
+	}
 }
 
 /// Removes the nick of charid from nick_db.
 /// Sends name to all pending requests on charid.
-void map_delnickdb(int charid, const char *name)
+void map_delnickdb(int charid, const char* name)
 {
-    struct charid2nick *p;
-    struct charid_request *req;
-    struct map_session_data *sd;
-    DBData data;
+	struct charid2nick* p;
+	struct charid_request* req;
+	struct map_session_data* sd;
+	DBData data;
 
-    if (!nick_db->remove(nick_db, db_i2key(charid), &data) || (p = db_data2ptr(&data)) == NULL)
-        return;
+	if (!nick_db->remove(nick_db, db_i2key(charid), &data) || (p = db_data2ptr(&data)) == NULL)
+		return;
 
-    while (p->requests) {
-        req = p->requests;
-        p->requests = req->next;
-        sd = map_charid2sd(req->charid);
-        if (sd)
-            clif_solved_charname(sd->fd, charid, name);
-        aFree(req);
-    }
-    aFree(p);
+	while( p->requests )
+	{
+		req = p->requests;
+		p->requests = req->next;
+		sd = map_charid2sd(req->charid);
+		if( sd )
+			clif_solved_charname(sd->fd, charid, name);
+		aFree(req);
+	}
+	aFree(p);
 }
 
 /// Notifies sd of the nick of charid.
 /// Uses the name in the character if online.
 /// Uses the name in nick_db if offline.
-void map_reqnickdb(struct map_session_data *sd, int charid)
-{
-    struct charid2nick *p;
-    struct charid_request *req;
-    struct map_session_data *tsd;
-
-    nullpo_retv(sd);
-
-    tsd = map_charid2sd(charid);
-    if (tsd) {
-        clif_solved_charname(sd->fd, charid, tsd->status.name);
-        return;
-    }
-
-    p = idb_ensure(nick_db, charid, create_charid2nick);
-    if (*p->nick) {
-        clif_solved_charname(sd->fd, charid, p->nick);
-        return;
-    }
-    // not in cache, request it
-    CREATE(req, struct charid_request, 1);
-    req->next = p->requests;
-    p->requests = req;
-    chrif_searchcharid(charid);
+void map_reqnickdb(struct map_session_data * sd, int charid)
+{
+	struct charid2nick* p;
+	struct charid_request* req;
+	struct map_session_data* tsd;
+
+	nullpo_retv(sd);
+
+	tsd = map_charid2sd(charid);
+	if( tsd )
+	{
+		clif_solved_charname(sd->fd, charid, tsd->status.name);
+		return;
+	}
+
+	p = idb_ensure(nick_db, charid, create_charid2nick);
+	if( *p->nick )
+	{
+		clif_solved_charname(sd->fd, charid, p->nick);
+		return;
+	}
+	// not in cache, request it
+	CREATE(req, struct charid_request, 1);
+	req->next = p->requests;
+	p->requests = req;
+	chrif_searchcharid(charid);
 }
 
 /*==========================================
@@ -1551,24 +1562,27 @@ void map_reqnickdb(struct map_session_data *sd, int charid)
  *------------------------------------------*/
 void map_addiddb(struct block_list *bl)
 {
-    nullpo_retv(bl);
+	nullpo_retv(bl);
 
-    if (bl->type == BL_PC) {
-        TBL_PC *sd = (TBL_PC *)bl;
-        idb_put(pc_db,sd->bl.id,sd);
-        idb_put(charid_db,sd->status.char_id,sd);
-    } else if (bl->type == BL_MOB) {
-        TBL_MOB *md = (TBL_MOB *)bl;
-        idb_put(mobid_db,bl->id,bl);
+	if( bl->type == BL_PC )
+	{
+		TBL_PC* sd = (TBL_PC*)bl;
+		idb_put(pc_db,sd->bl.id,sd);
+		idb_put(charid_db,sd->status.char_id,sd);
+	}
+	else if( bl->type == BL_MOB )
+	{
+		TBL_MOB* md = (TBL_MOB*)bl;
+		idb_put(mobid_db,bl->id,bl);
 
-        if (md->state.boss)
-            idb_put(bossid_db, bl->id, bl);
-    }
+		if( md->state.boss )
+			idb_put(bossid_db, bl->id, bl);
+	}
 
-    if (bl->type & BL_REGEN)
-        idb_put(regen_db, bl->id, bl);
+	if( bl->type & BL_REGEN )
+		idb_put(regen_db, bl->id, bl);
 
-    idb_put(id_db,bl->id,bl);
+	idb_put(id_db,bl->id,bl);
 }
 
 /*==========================================
@@ -1576,202 +1590,211 @@ void map_addiddb(struct block_list *bl)
  *------------------------------------------*/
 void map_deliddb(struct block_list *bl)
 {
-    nullpo_retv(bl);
+	nullpo_retv(bl);
 
-    if (bl->type == BL_PC) {
-        TBL_PC *sd = (TBL_PC *)bl;
-        idb_remove(pc_db,sd->bl.id);
-        idb_remove(charid_db,sd->status.char_id);
-    } else if (bl->type == BL_MOB) {
-        idb_remove(mobid_db,bl->id);
-        idb_remove(bossid_db,bl->id);
-    }
+	if( bl->type == BL_PC )
+	{
+		TBL_PC* sd = (TBL_PC*)bl;
+		idb_remove(pc_db,sd->bl.id);
+		idb_remove(charid_db,sd->status.char_id);
+	}
+	else if( bl->type == BL_MOB )
+	{
+		idb_remove(mobid_db,bl->id);
+		idb_remove(bossid_db,bl->id);
+	}
 
-    if (bl->type & BL_REGEN)
-        idb_remove(regen_db,bl->id);
+	if( bl->type & BL_REGEN )
+		idb_remove(regen_db,bl->id);
 
-    idb_remove(id_db,bl->id);
+	idb_remove(id_db,bl->id);
 }
 
 /*==========================================
  * Standard call when a player connection is closed.
  *------------------------------------------*/
-int map_quit(struct map_session_data *sd)
-{
-    int i;
-
-    if (!sd->state.active) { //Removing a player that is not active.
-        struct auth_node *node = chrif_search(sd->status.account_id);
-        if (node && node->char_id == sd->status.char_id &&
-            node->state != ST_LOGOUT)
-            //Except when logging out, clear the auth-connect data immediately.
-            chrif_auth_delete(node->account_id, node->char_id, node->state);
-        //Non-active players should not have loaded any data yet (or it was cleared already) so no additional cleanups are needed.
-        return 0;
-    }
-
-    if (sd->npc_timer_id != INVALID_TIMER) //Cancel the event timer.
-        npc_timerevent_quit(sd);
-
-    if (sd->npc_id)
-        npc_event_dequeue(sd);
-
-    if (sd->bg_id)
-        bg_team_leave(sd,1);
-
-    pc_itemcd_do(sd,false);
-
-    npc_script_event(sd, NPCE_LOGOUT);
-
-    //Unit_free handles clearing the player related data,
-    //map_quit handles extra specific data which is related to quitting normally
-    //(changing map-servers invokes unit_free but bypasses map_quit)
-    if (sd->sc.count) {
-        //Status that are not saved...
-        status_change_end(&sd->bl, SC_BOSSMAPINFO, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_AUTOTRADE, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_SPURT, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_BERSERK, INVALID_TIMER);
-        status_change_end(&sd->bl, SC__BLOODYLUST, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_TRICKDEAD, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_LEADERSHIP, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_GLORYWOUNDS, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_SOULCOLD, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_HAWKEYES, INVALID_TIMER);
-        if (sd->sc.data[SC_ENDURE] && sd->sc.data[SC_ENDURE]->val4)
-            status_change_end(&sd->bl, SC_ENDURE, INVALID_TIMER); //No need to save infinite endure.
-        status_change_end(&sd->bl, SC_WEIGHT50, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_WEIGHT90, INVALID_TIMER);
+int map_quit(struct map_session_data *sd) {
+	int i;
+
+	if(!sd->state.active) { //Removing a player that is not active.
+		struct auth_node *node = chrif_search(sd->status.account_id);
+		if (node && node->char_id == sd->status.char_id &&
+			node->state != ST_LOGOUT)
+			//Except when logging out, clear the auth-connect data immediately.
+			chrif_auth_delete(node->account_id, node->char_id, node->state);
+		//Non-active players should not have loaded any data yet (or it was cleared already) so no additional cleanups are needed.
+		return 0;
+	}
+
+	if (sd->npc_timer_id != INVALID_TIMER) //Cancel the event timer.
+		npc_timerevent_quit(sd);
+
+	if (sd->npc_id)
+		npc_event_dequeue(sd);
+
+	if( sd->bg_id )
+		bg_team_leave(sd,1);
+
+	pc_itemcd_do(sd,false);
+
+	npc_script_event(sd, NPCE_LOGOUT);
+
+	//Unit_free handles clearing the player related data,
+	//map_quit handles extra specific data which is related to quitting normally
+	//(changing map-servers invokes unit_free but bypasses map_quit)
+	if( sd->sc.count ) {
+		//Status that are not saved...
+		status_change_end(&sd->bl, SC_BOSSMAPINFO, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_AUTOTRADE, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_SPURT, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_BERSERK, INVALID_TIMER);
+		status_change_end(&sd->bl, SC__BLOODYLUST, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_TRICKDEAD, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_LEADERSHIP, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_GLORYWOUNDS, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_SOULCOLD, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_HAWKEYES, INVALID_TIMER);
+		if(sd->sc.data[SC_ENDURE] && sd->sc.data[SC_ENDURE]->val4)
+			status_change_end(&sd->bl, SC_ENDURE, INVALID_TIMER); //No need to save infinite endure.
+		status_change_end(&sd->bl, SC_WEIGHT50, INVALID_TIMER);
+		status_change_end(&sd->bl, SC_WEIGHT90, INVALID_TIMER);
         status_change_end(&sd->bl, SC_SATURDAYNIGHTFEVER, INVALID_TIMER);
-        status_change_end(&sd->bl, SC_KYOUGAKU, INVALID_TIMER);
-        if (battle_config.debuff_on_logout&1) {
-            status_change_end(&sd->bl, SC_ORCISH, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_STRIPWEAPON, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_STRIPARMOR, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_STRIPSHIELD, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_STRIPHELM, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_EXTREMITYFIST, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_EXPLOSIONSPIRITS, INVALID_TIMER);
-            if (sd->sc.data[SC_REGENERATION] && sd->sc.data[SC_REGENERATION]->val4)
-                status_change_end(&sd->bl, SC_REGENERATION, INVALID_TIMER);
-            //TO-DO Probably there are way more NPC_type negative status that are removed
-            status_change_end(&sd->bl, SC_CHANGEUNDEAD, INVALID_TIMER);
-            // Both these statuses are removed on logout. [L0ne_W0lf]
-            status_change_end(&sd->bl, SC_SLOWCAST, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_CRITICALWOUND, INVALID_TIMER);
-        }
-        if (battle_config.debuff_on_logout&2) {
-            status_change_end(&sd->bl, SC_MAXIMIZEPOWER, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_MAXOVERTHRUST, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_STEELBODY, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_PRESERVE, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_KAAHI, INVALID_TIMER);
-            status_change_end(&sd->bl, SC_SPIRIT, INVALID_TIMER);
-        }
-    }
-
-    for (i = 0; i < EQI_MAX; i++) {
-        if (sd->equip_index[ i ] >= 0)
-            if (!pc_isequip(sd , sd->equip_index[ i ]))
-                pc_unequipitem(sd , sd->equip_index[ i ] , 2);
-    }
-
-    // Return loot to owner
-    if (sd->pd) pet_lootitem_drop(sd->pd, sd);
-
-    if (sd->state.storage_flag == 1) sd->state.storage_flag = 0;  // No need to Double Save Storage on Quit.
-
-    if (sd->ed) {
-        elemental_clean_effect(sd->ed);
-        unit_remove_map(&sd->ed->bl,CLR_TELEPORT);
-    }
-
-    unit_remove_map_pc(sd,CLR_TELEPORT);
-
-    if (map[sd->bl.m].instance_id) {
-        // Avoid map conflicts and warnings on next login
-        int m;
-        struct point *pt;
-        if (map[sd->bl.m].save.map)
-            pt = &map[sd->bl.m].save;
-        else
-            pt = &sd->status.save_point;
-
-        if ((m=map_mapindex2mapid(pt->map)) >= 0) {
-            sd->bl.m = m;
-            sd->bl.x = pt->x;
-            sd->bl.y = pt->y;
-            sd->mapindex = pt->map;
-        }
-    }
-
-    party_booking_delete(sd); // Party Booking [Spiria]
-    pc_makesavestatus(sd);
-    pc_clean_skilltree(sd);
-    chrif_save(sd,1);
-    unit_free_pc(sd);
-    return 0;
+		status_change_end(&sd->bl, SC_KYOUGAKU, INVALID_TIMER);
+		if (battle_config.debuff_on_logout&1) {
+			status_change_end(&sd->bl, SC_ORCISH, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_STRIPWEAPON, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_STRIPARMOR, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_STRIPSHIELD, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_STRIPHELM, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_EXTREMITYFIST, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_EXPLOSIONSPIRITS, INVALID_TIMER);
+			if(sd->sc.data[SC_REGENERATION] && sd->sc.data[SC_REGENERATION]->val4)
+				status_change_end(&sd->bl, SC_REGENERATION, INVALID_TIMER);
+			//TO-DO Probably there are way more NPC_type negative status that are removed
+			status_change_end(&sd->bl, SC_CHANGEUNDEAD, INVALID_TIMER);
+			// Both these statuses are removed on logout. [L0ne_W0lf]
+			status_change_end(&sd->bl, SC_SLOWCAST, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_CRITICALWOUND, INVALID_TIMER);
+		}
+		if (battle_config.debuff_on_logout&2) {
+			status_change_end(&sd->bl, SC_MAXIMIZEPOWER, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_MAXOVERTHRUST, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_STEELBODY, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_PRESERVE, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_KAAHI, INVALID_TIMER);
+			status_change_end(&sd->bl, SC_SPIRIT, INVALID_TIMER);
+		}
+	}
+
+	for( i = 0; i < EQI_MAX; i++ ) {
+		if( sd->equip_index[ i ] >= 0 )
+			if( !pc_isequip( sd , sd->equip_index[ i ] ) )
+				pc_unequipitem( sd , sd->equip_index[ i ] , 2 );
+	}
+
+	// Return loot to owner
+	if( sd->pd ) pet_lootitem_drop(sd->pd, sd);
+
+	if( sd->state.storage_flag == 1 ) sd->state.storage_flag = 0; // No need to Double Save Storage on Quit.
+
+	if( sd->ed ) {
+		elemental_clean_effect(sd->ed);
+		unit_remove_map(&sd->ed->bl,CLR_TELEPORT);
+	}
+
+	unit_remove_map_pc(sd,CLR_TELEPORT);
+
+	if( map[sd->bl.m].instance_id )
+	{ // Avoid map conflicts and warnings on next login
+		int m;
+		struct point *pt;
+		if( map[sd->bl.m].save.map )
+			pt = &map[sd->bl.m].save;
+		else
+			pt = &sd->status.save_point;
+
+		if( (m=map_mapindex2mapid(pt->map)) >= 0 )
+		{
+			sd->bl.m = m;
+			sd->bl.x = pt->x;
+			sd->bl.y = pt->y;
+			sd->mapindex = pt->map;
+		}
+	}
+
+	party_booking_delete(sd); // Party Booking [Spiria]
+	pc_makesavestatus(sd);
+	pc_clean_skilltree(sd);
+	chrif_save(sd,1);
+	unit_free_pc(sd);
+	return 0;
 }
 
 /*==========================================
  * Lookup, id to session (player,mob,npc,homon,merc..)
  *------------------------------------------*/
-struct map_session_data *map_id2sd(int id) {
-    if (id <= 0) return NULL;
-    return (struct map_session_data *)idb_get(pc_db,id);
+struct map_session_data * map_id2sd(int id)
+{
+	if (id <= 0) return NULL;
+	return (struct map_session_data*)idb_get(pc_db,id);
 }
 
-struct mob_data *map_id2md(int id) {
-    if (id <= 0) return NULL;
-    return (struct mob_data *)idb_get(mobid_db,id);
+struct mob_data * map_id2md(int id)
+{
+	if (id <= 0) return NULL;
+	return (struct mob_data*)idb_get(mobid_db,id);
 }
 
-struct npc_data *map_id2nd(int id) {
-    // just a id2bl lookup because there's no npc_db
-    struct block_list *bl = map_id2bl(id);
+struct npc_data * map_id2nd(int id)
+{// just a id2bl lookup because there's no npc_db
+	struct block_list* bl = map_id2bl(id);
 
-    return BL_CAST(BL_NPC, bl);
+	return BL_CAST(BL_NPC, bl);
 }
 
-struct homun_data *map_id2hd(int id) {
-    struct block_list *bl = map_id2bl(id);
+struct homun_data* map_id2hd(int id)
+{
+	struct block_list* bl = map_id2bl(id);
 
-    return BL_CAST(BL_HOM, bl);
+	return BL_CAST(BL_HOM, bl);
 }
 
-struct mercenary_data *map_id2mc(int id) {
-    struct block_list *bl = map_id2bl(id);
+struct mercenary_data* map_id2mc(int id)
+{
+	struct block_list* bl = map_id2bl(id);
 
-    return BL_CAST(BL_MER, bl);
+	return BL_CAST(BL_MER, bl);
 }
 
-struct chat_data *map_id2cd(int id) {
-    struct block_list *bl = map_id2bl(id);
+struct chat_data* map_id2cd(int id)
+{
+	struct block_list* bl = map_id2bl(id);
 
-    return BL_CAST(BL_CHAT, bl);
+	return BL_CAST(BL_CHAT, bl);
 }
 
 /// Returns the nick of the target charid or NULL if unknown (requests the nick to the char server).
-const char *map_charid2nick(int charid)
+const char* map_charid2nick(int charid)
 {
-    struct charid2nick *p;
-    struct map_session_data *sd;
+	struct charid2nick *p;
+	struct map_session_data* sd;
 
-    sd = map_charid2sd(charid);
-    if (sd)
-        return sd->status.name;// character is online, return it's name
+	sd = map_charid2sd(charid);
+	if( sd )
+		return sd->status.name;// character is online, return it's name
 
-    p = idb_ensure(nick_db, charid, create_charid2nick);
-    if (*p->nick)
-        return p->nick;// name in nick_db
+	p = idb_ensure(nick_db, charid, create_charid2nick);
+	if( *p->nick )
+		return p->nick;// name in nick_db
 
-    chrif_searchcharid(charid);// request the name
-    return NULL;
+	chrif_searchcharid(charid);// request the name
+	return NULL;
 }
 
 /// Returns the struct map_session_data of the charid or NULL if the char is not online.
-struct map_session_data *map_charid2sd(int charid) {
-    return (struct map_session_data *)idb_get(charid_db, charid);
+struct map_session_data* map_charid2sd(int charid)
+{
+	return (struct map_session_data*)idb_get(charid_db, charid);
 }
 
 /*==========================================
@@ -1779,202 +1802,216 @@ struct map_session_data *map_charid2sd(int charid) {
  * (without sensitive case if necessary)
  * return map_session_data pointer or NULL
  *------------------------------------------*/
-struct map_session_data *map_nick2sd(const char *nick) {
-    struct map_session_data *sd;
-    struct map_session_data *found_sd;
-    struct s_mapiterator *iter;
-    size_t nicklen;
-    int qty = 0;
-
-    if (nick == NULL)
-        return NULL;
-
-    nicklen = strlen(nick);
-    iter = mapit_getallusers();
-
-    found_sd = NULL;
-    for (sd = (TBL_PC *)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC *)mapit_next(iter)) {
-        if (battle_config.partial_name_scan) {
-            // partial name search
-            if (strnicmp(sd->status.name, nick, nicklen) == 0) {
-                found_sd = sd;
-
-                if (strcmp(sd->status.name, nick) == 0) {
-                    // Perfect Match
-                    qty = 1;
-                    break;
-                }
-
-                qty++;
-            }
-        } else if (strcasecmp(sd->status.name, nick) == 0) {
-            // exact search only
-            found_sd = sd;
-            break;
-        }
-    }
-    mapit_free(iter);
-
-    if (battle_config.partial_name_scan && qty != 1)
-        found_sd = NULL;
-
-    return found_sd;
+struct map_session_data * map_nick2sd(const char *nick)
+{
+	struct map_session_data* sd;
+	struct map_session_data* found_sd;
+	struct s_mapiterator* iter;
+	size_t nicklen;
+	int qty = 0;
+
+	if( nick == NULL )
+		return NULL;
+
+	nicklen = strlen(nick);
+	iter = mapit_getallusers();
+
+	found_sd = NULL;
+	for( sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC*)mapit_next(iter) )
+	{
+		if( battle_config.partial_name_scan )
+		{// partial name search
+			if( strnicmp(sd->status.name, nick, nicklen) == 0 )
+			{
+				found_sd = sd;
+
+				if( strcmp(sd->status.name, nick) == 0 )
+				{// Perfect Match
+					qty = 1;
+					break;
+				}
+
+				qty++;
+			}
+		}
+		else if( strcasecmp(sd->status.name, nick) == 0 )
+		{// exact search only
+			found_sd = sd;
+			break;
+		}
+	}
+	mapit_free(iter);
+
+	if( battle_config.partial_name_scan && qty != 1 )
+		found_sd = NULL;
+
+	return found_sd;
 }
 
 /*==========================================
  * Looksup id_db DBMap and returns BL pointer of 'id' or NULL if not found
  *------------------------------------------*/
-struct block_list *map_id2bl(int id) {
-    return (struct block_list *)idb_get(id_db,id);
+struct block_list * map_id2bl(int id) {
+	return (struct block_list*)idb_get(id_db,id);
 }
 
 /**
  * Same as map_id2bl except it only checks for its existence
  **/
-bool map_blid_exists(int id)
-{
-    return (idb_exists(id_db,id));
+bool map_blid_exists( int id ) {
+	return (idb_exists(id_db,id));
 }
 
 /*==========================================
  * Convext Mirror
  *------------------------------------------*/
-struct mob_data *map_getmob_boss(int m) {
-    DBIterator *iter;
-    struct mob_data *md = NULL;
-    bool found = false;
+struct mob_data * map_getmob_boss(int m)
+{
+	DBIterator* iter;
+	struct mob_data *md = NULL;
+	bool found = false;
 
-    iter = db_iterator(bossid_db);
-    for (md = (struct mob_data *)dbi_first(iter); dbi_exists(iter); md = (struct mob_data *)dbi_next(iter)) {
-        if (md->bl.m == m) {
-            found = true;
-            break;
-        }
-    }
-    dbi_destroy(iter);
+	iter = db_iterator(bossid_db);
+	for( md = (struct mob_data*)dbi_first(iter); dbi_exists(iter); md = (struct mob_data*)dbi_next(iter) )
+	{
+		if( md->bl.m == m )
+		{
+			found = true;
+			break;
+		}
+	}
+	dbi_destroy(iter);
 
-    return (found)? md : NULL;
+	return (found)? md : NULL;
 }
 
-struct mob_data *map_id2boss(int id) {
-    if (id <= 0) return NULL;
-    return (struct mob_data *)idb_get(bossid_db,id);
+struct mob_data * map_id2boss(int id)
+{
+	if (id <= 0) return NULL;
+	return (struct mob_data*)idb_get(bossid_db,id);
 }
 
 /// Applies func to all the players in the db.
 /// Stops iterating if func returns -1.
-void map_foreachpc(int (*func)(struct map_session_data *sd, va_list args), ...)
+void map_foreachpc(int (*func)(struct map_session_data* sd, va_list args), ...)
 {
-    DBIterator *iter;
-    struct map_session_data *sd;
+	DBIterator* iter;
+	struct map_session_data* sd;
 
-    iter = db_iterator(pc_db);
-    for (sd = dbi_first(iter); dbi_exists(iter); sd = dbi_next(iter)) {
-        va_list args;
-        int ret;
+	iter = db_iterator(pc_db);
+	for( sd = dbi_first(iter); dbi_exists(iter); sd = dbi_next(iter) )
+	{
+		va_list args;
+		int ret;
 
-        va_start(args, func);
-        ret = func(sd, args);
-        va_end(args);
-        if (ret == -1)
-            break;// stop iterating
-    }
-    dbi_destroy(iter);
+		va_start(args, func);
+		ret = func(sd, args);
+		va_end(args);
+		if( ret == -1 )
+			break;// stop iterating
+	}
+	dbi_destroy(iter);
 }
 
 /// Applies func to all the mobs in the db.
 /// Stops iterating if func returns -1.
-void map_foreachmob(int (*func)(struct mob_data *md, va_list args), ...)
+void map_foreachmob(int (*func)(struct mob_data* md, va_list args), ...)
 {
-    DBIterator *iter;
-    struct mob_data *md;
+	DBIterator* iter;
+	struct mob_data* md;
 
-    iter = db_iterator(mobid_db);
-    for (md = (struct mob_data *)dbi_first(iter); dbi_exists(iter); md = (struct mob_data *)dbi_next(iter)) {
-        va_list args;
-        int ret;
+	iter = db_iterator(mobid_db);
+	for( md = (struct mob_data*)dbi_first(iter); dbi_exists(iter); md = (struct mob_data*)dbi_next(iter) )
+	{
+		va_list args;
+		int ret;
 
-        va_start(args, func);
-        ret = func(md, args);
-        va_end(args);
-        if (ret == -1)
-            break;// stop iterating
-    }
-    dbi_destroy(iter);
+		va_start(args, func);
+		ret = func(md, args);
+		va_end(args);
+		if( ret == -1 )
+			break;// stop iterating
+	}
+	dbi_destroy(iter);
 }
 
 /// Applies func to all the npcs in the db.
 /// Stops iterating if func returns -1.
-void map_foreachnpc(int (*func)(struct npc_data *nd, va_list args), ...)
-{
-    DBIterator *iter;
-    struct block_list *bl;
-
-    iter = db_iterator(id_db);
-    for (bl = (struct block_list *)dbi_first(iter); dbi_exists(iter); bl = (struct block_list *)dbi_next(iter)) {
-        if (bl->type == BL_NPC) {
-            struct npc_data *nd = (struct npc_data *)bl;
-            va_list args;
-            int ret;
-
-            va_start(args, func);
-            ret = func(nd, args);
-            va_end(args);
-            if (ret == -1)
-                break;// stop iterating
-        }
-    }
-    dbi_destroy(iter);
+void map_foreachnpc(int (*func)(struct npc_data* nd, va_list args), ...)
+{
+	DBIterator* iter;
+	struct block_list* bl;
+
+	iter = db_iterator(id_db);
+	for( bl = (struct block_list*)dbi_first(iter); dbi_exists(iter); bl = (struct block_list*)dbi_next(iter) )
+	{
+		if( bl->type == BL_NPC )
+		{
+			struct npc_data* nd = (struct npc_data*)bl;
+			va_list args;
+			int ret;
+
+			va_start(args, func);
+			ret = func(nd, args);
+			va_end(args);
+			if( ret == -1 )
+				break;// stop iterating
+		}
+	}
+	dbi_destroy(iter);
 }
 
 /// Applies func to everything in the db.
 /// Stops iteratin gif func returns -1.
-void map_foreachregen(int (*func)(struct block_list *bl, va_list args), ...)
+void map_foreachregen(int (*func)(struct block_list* bl, va_list args), ...)
 {
-    DBIterator *iter;
-    struct block_list *bl;
+	DBIterator* iter;
+	struct block_list* bl;
 
-    iter = db_iterator(regen_db);
-    for (bl = (struct block_list *)dbi_first(iter); dbi_exists(iter); bl = (struct block_list *)dbi_next(iter)) {
-        va_list args;
-        int ret;
+	iter = db_iterator(regen_db);
+	for( bl = (struct block_list*)dbi_first(iter); dbi_exists(iter); bl = (struct block_list*)dbi_next(iter) )
+	{
+		va_list args;
+		int ret;
 
-        va_start(args, func);
-        ret = func(bl, args);
-        va_end(args);
-        if (ret == -1)
-            break;// stop iterating
-    }
-    dbi_destroy(iter);
+		va_start(args, func);
+		ret = func(bl, args);
+		va_end(args);
+		if( ret == -1 )
+			break;// stop iterating
+	}
+	dbi_destroy(iter);
 }
 
 /// Applies func to everything in the db.
 /// Stops iterating if func returns -1.
-void map_foreachiddb(int (*func)(struct block_list *bl, va_list args), ...)
+void map_foreachiddb(int (*func)(struct block_list* bl, va_list args), ...)
 {
-    DBIterator *iter;
-    struct block_list *bl;
+	DBIterator* iter;
+	struct block_list* bl;
 
-    iter = db_iterator(id_db);
-    for (bl = (struct block_list *)dbi_first(iter); dbi_exists(iter); bl = (struct block_list *)dbi_next(iter)) {
-        va_list args;
-        int ret;
+	iter = db_iterator(id_db);
+	for( bl = (struct block_list*)dbi_first(iter); dbi_exists(iter); bl = (struct block_list*)dbi_next(iter) )
+	{
+		va_list args;
+		int ret;
 
-        va_start(args, func);
-        ret = func(bl, args);
-        va_end(args);
-        if (ret == -1)
-            break;// stop iterating
-    }
-    dbi_destroy(iter);
+		va_start(args, func);
+		ret = func(bl, args);
+		va_end(args);
+		if( ret == -1 )
+			break;// stop iterating
+	}
+	dbi_destroy(iter);
 }
 
 /// Iterator.
 /// Can filter by bl type.
-struct s_mapiterator {
-    enum e_mapitflags flags;// flags for special behaviour
-    enum bl_type types;// what bl types to return
-    DBIterator *dbi;// database iterator
+struct s_mapiterator
+{
+	enum e_mapitflags flags;// flags for special behaviour
+	enum bl_type types;// what bl types to return
+	DBIterator* dbi;// database iterator
 };
 
 /// Returns true if the block_list matches the description in the iterator.
@@ -1983,9 +2020,9 @@ struct s_mapiterator {
 /// @param _bl_ block_list
 /// @return true if it matches
 #define MAPIT_MATCHES(_mapit_,_bl_) \
-    ( \
-      ( (_bl_)->type & (_mapit_)->types /* type matches */ ) \
-    )
+	( \
+		( (_bl_)->type & (_mapit_)->types /* type matches */ ) \
+	)
 
 /// Allocates a new iterator.
 /// Returns the new iterator.
@@ -1995,27 +2032,28 @@ struct s_mapiterator {
 /// @param flags Flags of the iterator
 /// @param type Target types
 /// @return Iterator
-struct s_mapiterator *mapit_alloc(enum e_mapitflags flags, enum bl_type types) {
-    struct s_mapiterator *mapit;
+struct s_mapiterator* mapit_alloc(enum e_mapitflags flags, enum bl_type types)
+{
+	struct s_mapiterator* mapit;
 
-    CREATE(mapit, struct s_mapiterator, 1);
-    mapit->flags = flags;
-    mapit->types = types;
-    if (types == BL_PC)       mapit->dbi = db_iterator(pc_db);
-    else if (types == BL_MOB) mapit->dbi = db_iterator(mobid_db);
-    else                       mapit->dbi = db_iterator(id_db);
-    return mapit;
+	CREATE(mapit, struct s_mapiterator, 1);
+	mapit->flags = flags;
+	mapit->types = types;
+	if( types == BL_PC )       mapit->dbi = db_iterator(pc_db);
+	else if( types == BL_MOB ) mapit->dbi = db_iterator(mobid_db);
+	else                       mapit->dbi = db_iterator(id_db);
+	return mapit;
 }
 
 /// Frees the iterator.
 ///
 /// @param mapit Iterator
-void mapit_free(struct s_mapiterator *mapit)
+void mapit_free(struct s_mapiterator* mapit)
 {
-    nullpo_retv(mapit);
+	nullpo_retv(mapit);
 
-    dbi_destroy(mapit->dbi);
-    aFree(mapit);
+	dbi_destroy(mapit->dbi);
+	aFree(mapit);
 }
 
 /// Returns the first block_list that matches the description.
@@ -2023,16 +2061,18 @@ void mapit_free(struct s_mapiterator *mapit)
 ///
 /// @param mapit Iterator
 /// @return first block_list or NULL
-struct block_list *mapit_first(struct s_mapiterator *mapit) {
-    struct block_list *bl;
+struct block_list* mapit_first(struct s_mapiterator* mapit)
+{
+	struct block_list* bl;
 
-    nullpo_retr(NULL,mapit);
+	nullpo_retr(NULL,mapit);
 
-    for (bl = (struct block_list *)dbi_first(mapit->dbi); bl != NULL; bl = (struct block_list *)dbi_next(mapit->dbi)) {
-        if (MAPIT_MATCHES(mapit,bl))
-            break;// found match
-    }
-    return bl;
+	for( bl = (struct block_list*)dbi_first(mapit->dbi); bl != NULL; bl = (struct block_list*)dbi_next(mapit->dbi) )
+	{
+		if( MAPIT_MATCHES(mapit,bl) )
+			break;// found match
+	}
+	return bl;
 }
 
 /// Returns the last block_list that matches the description.
@@ -2040,16 +2080,18 @@ struct block_list *mapit_first(struct s_mapiterator *mapit) {
 ///
 /// @param mapit Iterator
 /// @return last block_list or NULL
-struct block_list *mapit_last(struct s_mapiterator *mapit) {
-    struct block_list *bl;
+struct block_list* mapit_last(struct s_mapiterator* mapit)
+{
+	struct block_list* bl;
 
-    nullpo_retr(NULL,mapit);
+	nullpo_retr(NULL,mapit);
 
-    for (bl = (struct block_list *)dbi_last(mapit->dbi); bl != NULL; bl = (struct block_list *)dbi_prev(mapit->dbi)) {
-        if (MAPIT_MATCHES(mapit,bl))
-            break;// found match
-    }
-    return bl;
+	for( bl = (struct block_list*)dbi_last(mapit->dbi); bl != NULL; bl = (struct block_list*)dbi_prev(mapit->dbi) )
+	{
+		if( MAPIT_MATCHES(mapit,bl) )
+			break;// found match
+	}
+	return bl;
 }
 
 /// Returns the next block_list that matches the description.
@@ -2057,20 +2099,22 @@ struct block_list *mapit_last(struct s_mapiterator *mapit) {
 ///
 /// @param mapit Iterator
 /// @return next block_list or NULL
-struct block_list *mapit_next(struct s_mapiterator *mapit) {
-    struct block_list *bl;
+struct block_list* mapit_next(struct s_mapiterator* mapit)
+{
+	struct block_list* bl;
 
-    nullpo_retr(NULL,mapit);
+	nullpo_retr(NULL,mapit);
 
-    for (; ;) {
-        bl = (struct block_list *)dbi_next(mapit->dbi);
-        if (bl == NULL)
-            break;// end
-        if (MAPIT_MATCHES(mapit,bl))
-            break;// found a match
-        // try next
-    }
-    return bl;
+	for( ; ; )
+	{
+		bl = (struct block_list*)dbi_next(mapit->dbi);
+		if( bl == NULL )
+			break;// end
+		if( MAPIT_MATCHES(mapit,bl) )
+			break;// found a match
+		// try next
+	}
+	return bl;
 }
 
 /// Returns the previous block_list that matches the description.
@@ -2078,31 +2122,33 @@ struct block_list *mapit_next(struct s_mapiterator *mapit) {
 ///
 /// @param mapit Iterator
 /// @return previous block_list or NULL
-struct block_list *mapit_prev(struct s_mapiterator *mapit) {
-    struct block_list *bl;
+struct block_list* mapit_prev(struct s_mapiterator* mapit)
+{
+	struct block_list* bl;
 
-    nullpo_retr(NULL,mapit);
+	nullpo_retr(NULL,mapit);
 
-    for (; ;) {
-        bl = (struct block_list *)dbi_prev(mapit->dbi);
-        if (bl == NULL)
-            break;// end
-        if (MAPIT_MATCHES(mapit,bl))
-            break;// found a match
-        // try prev
-    }
-    return bl;
+	for( ; ; )
+	{
+		bl = (struct block_list*)dbi_prev(mapit->dbi);
+		if( bl == NULL )
+			break;// end
+		if( MAPIT_MATCHES(mapit,bl) )
+			break;// found a match
+		// try prev
+	}
+	return bl;
 }
 
 /// Returns true if the current block_list exists in the database.
 ///
 /// @param mapit Iterator
 /// @return true if it exists
-bool mapit_exists(struct s_mapiterator *mapit)
+bool mapit_exists(struct s_mapiterator* mapit)
 {
-    nullpo_retr(false,mapit);
+	nullpo_retr(false,mapit);
 
-    return dbi_exists(mapit->dbi);
+	return dbi_exists(mapit->dbi);
 }
 
 /*==========================================
@@ -2110,20 +2156,21 @@ bool mapit_exists(struct s_mapiterator *mapit)
  *------------------------------------------*/
 bool map_addnpc(int m,struct npc_data *nd)
 {
-    nullpo_ret(nd);
+	nullpo_ret(nd);
 
-    if (m < 0 || m >= map_num)
-        return false;
+	if( m < 0 || m >= map_num )
+		return false;
 
-    if (map[m].npc_num == MAX_NPC_PER_MAP) {
-        ShowWarning("too many NPCs in one map %s\n",map[m].name);
-        return false;
-    }
+	if( map[m].npc_num == MAX_NPC_PER_MAP )
+	{
+		ShowWarning("too many NPCs in one map %s\n",map[m].name);
+		return false;
+	}
 
-    map[m].npc[map[m].npc_num]=nd;
-    map[m].npc_num++;
-    idb_put(id_db,nd->bl.id,nd);
-    return true;
+	map[m].npc[map[m].npc_num]=nd;
+	map[m].npc_num++;
+	idb_put(id_db,nd->bl.id,nd);
+	return true;
 }
 
 /*=========================================
@@ -2133,107 +2180,110 @@ bool map_addnpc(int m,struct npc_data *nd)
 // Returns the index of successful, or -1 if the list was full.
 int map_addmobtolist(unsigned short m, struct spawn_data *spawn)
 {
-    size_t i;
-    ARR_FIND(0, MAX_MOB_LIST_PER_MAP, i, map[m].moblist[i] == NULL);
-    if (i < MAX_MOB_LIST_PER_MAP) {
-        map[m].moblist[i] = spawn;
-        return i;
-    }
-    return -1;
+	size_t i;
+	ARR_FIND( 0, MAX_MOB_LIST_PER_MAP, i, map[m].moblist[i] == NULL );
+	if( i < MAX_MOB_LIST_PER_MAP )
+	{
+		map[m].moblist[i] = spawn;
+		return i;
+	}
+	return -1;
 }
 
 void map_spawnmobs(int m)
 {
-    int i, k=0;
-    if (map[m].mob_delete_timer != INVALID_TIMER) {
-        //Mobs have not been removed yet [Skotlex]
-        delete_timer(map[m].mob_delete_timer, map_removemobs_timer);
-        map[m].mob_delete_timer = INVALID_TIMER;
-        return;
-    }
-    for (i=0; i<MAX_MOB_LIST_PER_MAP; i++)
-        if (map[m].moblist[i]!=NULL) {
-            k+=map[m].moblist[i]->num;
-            npc_parse_mob2(map[m].moblist[i]);
-        }
-
-    if (battle_config.etc_log && k > 0) {
-        ShowStatus("Map %s: Spawned '"CL_WHITE"%d"CL_RESET"' mobs.\n",map[m].name, k);
-    }
+	int i, k=0;
+	if (map[m].mob_delete_timer != INVALID_TIMER)
+	{	//Mobs have not been removed yet [Skotlex]
+		delete_timer(map[m].mob_delete_timer, map_removemobs_timer);
+		map[m].mob_delete_timer = INVALID_TIMER;
+		return;
+	}
+	for(i=0; i<MAX_MOB_LIST_PER_MAP; i++)
+		if(map[m].moblist[i]!=NULL)
+		{
+			k+=map[m].moblist[i]->num;
+			npc_parse_mob2(map[m].moblist[i]);
+		}
+
+	if (battle_config.etc_log && k > 0)
+	{
+		ShowStatus("Map %s: Spawned '"CL_WHITE"%d"CL_RESET"' mobs.\n",map[m].name, k);
+	}
 }
 
 int map_removemobs_sub(struct block_list *bl, va_list ap)
 {
-    struct mob_data *md = (struct mob_data *)bl;
-    nullpo_ret(md);
+	struct mob_data *md = (struct mob_data *)bl;
+	nullpo_ret(md);
 
-    //When not to remove mob:
-    // doesn't respawn and is not a slave
-    if (!md->spawn && !md->master_id)
-        return 0;
-    // respawn data is not in cache
-    if (md->spawn && !md->spawn->state.dynamic)
-        return 0;
-    // hasn't spawned yet
-    if (md->spawn_timer != INVALID_TIMER)
-        return 0;
-    // is damaged and mob_remove_damaged is off
-    if (!battle_config.mob_remove_damaged && md->status.hp < md->status.max_hp)
-        return 0;
-    // is a mvp
-    if (md->db->mexp > 0)
-        return 0;
+	//When not to remove mob:
+	// doesn't respawn and is not a slave
+	if( !md->spawn && !md->master_id )
+		return 0;
+	// respawn data is not in cache
+	if( md->spawn && !md->spawn->state.dynamic )
+		return 0;
+	// hasn't spawned yet
+	if( md->spawn_timer != INVALID_TIMER )
+		return 0;
+	// is damaged and mob_remove_damaged is off
+	if( !battle_config.mob_remove_damaged && md->status.hp < md->status.max_hp )
+		return 0;
+	// is a mvp
+	if( md->db->mexp > 0 )
+		return 0;
 
-    unit_free(&md->bl,CLR_OUTSIGHT);
+	unit_free(&md->bl,CLR_OUTSIGHT);
 
-    return 1;
+	return 1;
 }
 
 int map_removemobs_timer(int tid, unsigned int tick, int id, intptr_t data)
 {
-    int count;
-    const int m = id;
+	int count;
+	const int m = id;
 
-    if (m < 0 || m >= MAX_MAP_PER_SERVER) {
-        //Incorrect map id!
-        ShowError("map_removemobs_timer error: timer %d points to invalid map %d\n",tid, m);
-        return 0;
-    }
-    if (map[m].mob_delete_timer != tid) {
-        //Incorrect timer call!
-        ShowError("map_removemobs_timer mismatch: %d != %d (map %s)\n",map[m].mob_delete_timer, tid, map[m].name);
-        return 0;
-    }
-    map[m].mob_delete_timer = INVALID_TIMER;
-    if (map[m].users > 0) //Map not empty!
-        return 1;
+	if (m < 0 || m >= MAX_MAP_PER_SERVER)
+	{	//Incorrect map id!
+		ShowError("map_removemobs_timer error: timer %d points to invalid map %d\n",tid, m);
+		return 0;
+	}
+	if (map[m].mob_delete_timer != tid)
+	{	//Incorrect timer call!
+		ShowError("map_removemobs_timer mismatch: %d != %d (map %s)\n",map[m].mob_delete_timer, tid, map[m].name);
+		return 0;
+	}
+	map[m].mob_delete_timer = INVALID_TIMER;
+	if (map[m].users > 0) //Map not empty!
+		return 1;
 
-    count = map_foreachinmap(map_removemobs_sub, m, BL_MOB);
+	count = map_foreachinmap(map_removemobs_sub, m, BL_MOB);
 
-    if (battle_config.etc_log && count > 0)
-        ShowStatus("Map %s: Removed '"CL_WHITE"%d"CL_RESET"' mobs.\n",map[m].name, count);
+	if (battle_config.etc_log && count > 0)
+		ShowStatus("Map %s: Removed '"CL_WHITE"%d"CL_RESET"' mobs.\n",map[m].name, count);
 
-    return 1;
+	return 1;
 }
 
 void map_removemobs(int m)
 {
-    if (map[m].mob_delete_timer != INVALID_TIMER) // should never happen
-        return; //Mobs are already scheduled for removal
+	if (map[m].mob_delete_timer != INVALID_TIMER) // should never happen
+		return; //Mobs are already scheduled for removal
 
-    map[m].mob_delete_timer = add_timer(gettick()+battle_config.mob_remove_delay, map_removemobs_timer, m, 0);
+	map[m].mob_delete_timer = add_timer(gettick()+battle_config.mob_remove_delay, map_removemobs_timer, m, 0);
 }
 
 /*==========================================
  * Hookup, get map_id from map_name
  *------------------------------------------*/
-int map_mapname2mapid(const char *name)
+int map_mapname2mapid(const char* name)
 {
-    unsigned short map_index;
-    map_index = mapindex_name2id(name);
-    if (!map_index)
-        return -1;
-    return map_mapindex2mapid(map_index);
+	unsigned short map_index;
+	map_index = mapindex_name2id(name);
+	if (!map_index)
+		return -1;
+	return map_mapindex2mapid(map_index);
 }
 
 /*==========================================
@@ -2241,30 +2291,30 @@ int map_mapname2mapid(const char *name)
  *------------------------------------------*/
 int map_mapindex2mapid(unsigned short mapindex)
 {
-    struct map_data *md=NULL;
+	struct map_data *md=NULL;
 
-    if (!mapindex)
-        return -1;
+	if (!mapindex)
+		return -1;
 
-    md = (struct map_data *)uidb_get(map_db,(unsigned int)mapindex);
-    if (md==NULL || md->cell==NULL)
-        return -1;
-    return md->m;
+	md = (struct map_data*)uidb_get(map_db,(unsigned int)mapindex);
+	if(md==NULL || md->cell==NULL)
+		return -1;
+	return md->m;
 }
 
 /*==========================================
  * Switching Ip, port ? (like changing map_server) get ip/port from map_name
  *------------------------------------------*/
-int map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port)
+int map_mapname2ipport(unsigned short name, uint32* ip, uint16* port)
 {
-    struct map_data_other_server *mdos=NULL;
+	struct map_data_other_server *mdos=NULL;
 
-    mdos = (struct map_data_other_server *)uidb_get(map_db,(unsigned int)name);
-    if (mdos==NULL || mdos->cell) //If gat isn't null, this is a local map.
-        return -1;
-    *ip=mdos->ip;
-    *port=mdos->port;
-    return 0;
+	mdos = (struct map_data_other_server*)uidb_get(map_db,(unsigned int)name);
+	if(mdos==NULL || mdos->cell) //If gat isn't null, this is a local map.
+		return -1;
+	*ip=mdos->ip;
+	*port=mdos->port;
+	return 0;
 }
 
 /*==========================================
@@ -2272,76 +2322,64 @@ int map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port)
  *------------------------------------------*/
 int map_check_dir(int s_dir,int t_dir)
 {
-    if (s_dir == t_dir)
-        return 0;
-    switch (s_dir) {
-        case 0:
-            if (t_dir == 7 || t_dir == 1 || t_dir == 0) return 0;
-            break;
-        case 1:
-            if (t_dir == 0 || t_dir == 2 || t_dir == 1) return 0;
-            break;
-        case 2:
-            if (t_dir == 1 || t_dir == 3 || t_dir == 2) return 0;
-            break;
-        case 3:
-            if (t_dir == 2 || t_dir == 4 || t_dir == 3) return 0;
-            break;
-        case 4:
-            if (t_dir == 3 || t_dir == 5 || t_dir == 4) return 0;
-            break;
-        case 5:
-            if (t_dir == 4 || t_dir == 6 || t_dir == 5) return 0;
-            break;
-        case 6:
-            if (t_dir == 5 || t_dir == 7 || t_dir == 6) return 0;
-            break;
-        case 7:
-            if (t_dir == 6 || t_dir == 0 || t_dir == 7) return 0;
-            break;
-    }
-    return 1;
+	if(s_dir == t_dir)
+		return 0;
+	switch(s_dir) {
+		case 0: if(t_dir == 7 || t_dir == 1 || t_dir == 0) return 0; break;
+		case 1: if(t_dir == 0 || t_dir == 2 || t_dir == 1) return 0; break;
+		case 2: if(t_dir == 1 || t_dir == 3 || t_dir == 2) return 0; break;
+		case 3: if(t_dir == 2 || t_dir == 4 || t_dir == 3) return 0; break;
+		case 4: if(t_dir == 3 || t_dir == 5 || t_dir == 4) return 0; break;
+		case 5: if(t_dir == 4 || t_dir == 6 || t_dir == 5) return 0; break;
+		case 6: if(t_dir == 5 || t_dir == 7 || t_dir == 6) return 0; break;
+		case 7: if(t_dir == 6 || t_dir == 0 || t_dir == 7) return 0; break;
+	}
+	return 1;
 }
 
 /*==========================================
  * Returns the direction of the given cell, relative to 'src'
  *------------------------------------------*/
-uint8 map_calc_dir(struct block_list *src, int x, int y)
-{
-    unsigned char dir = 0;
-    int dx, dy;
-
-    nullpo_ret(src);
-
-    dx = x-src->x;
-    dy = y-src->y;
-    if (dx == 0 && dy == 0) {
-        // both are standing on the same spot
-        //dir = 6; // aegis-style, makes knockback default to the left
-        dir = unit_getdir(src); // athena-style, makes knockback default to behind 'src'
-    } else if (dx >= 0 && dy >=0) {
-        // upper-right
-        if (dx*2 <= dy)      dir = 0;    // up
-        else if (dx > dy*2)  dir = 6;    // right
-        else                  dir = 7;  // up-right
-    } else if (dx >= 0 && dy <= 0) {
-        // lower-right
-        if (dx*2 <= -dy)     dir = 4;    // down
-        else if (dx > -dy*2) dir = 6;    // right
-        else                  dir = 5;  // down-right
-    } else if (dx <= 0 && dy <= 0) {
-        // lower-left
-        if (dx*2 >= dy)      dir = 4;    // down
-        else if (dx < dy*2)  dir = 2;    // left
-        else                  dir = 3;  // down-left
-    } else {
-        // upper-left
-        if (-dx*2 <= dy)     dir = 0;    // up
-        else if (-dx > dy*2) dir = 2;    // left
-        else                  dir = 1;  // up-left
-
-    }
-    return dir;
+uint8 map_calc_dir(struct block_list* src, int x, int y)
+{
+	unsigned char dir = 0;
+	int dx, dy;
+
+	nullpo_ret(src);
+
+	dx = x-src->x;
+	dy = y-src->y;
+	if( dx == 0 && dy == 0 )
+	{	// both are standing on the same spot
+		//dir = 6; // aegis-style, makes knockback default to the left
+		dir = unit_getdir(src); // athena-style, makes knockback default to behind 'src'
+	}
+	else if( dx >= 0 && dy >=0 )
+	{	// upper-right
+		if( dx*2 <= dy )      dir = 0;	// up
+		else if( dx > dy*2 )  dir = 6;	// right
+		else                  dir = 7;	// up-right
+	}
+	else if( dx >= 0 && dy <= 0 )
+	{	// lower-right
+		if( dx*2 <= -dy )     dir = 4;	// down
+		else if( dx > -dy*2 ) dir = 6;	// right
+		else                  dir = 5;	// down-right
+	}
+	else if( dx <= 0 && dy <= 0 )
+	{	// lower-left
+		if( dx*2 >= dy )      dir = 4;	// down
+		else if( dx < dy*2 )  dir = 2;	// left
+		else                  dir = 3;	// down-left
+	}
+	else
+	{	// upper-left
+		if( -dx*2 <= dy )     dir = 0;	// up
+		else if( -dx > dy*2 ) dir = 2;	// left
+		else                  dir = 1;	// up-left
+
+	}
+	return dir;
 }
 
 /*==========================================
@@ -2350,92 +2388,64 @@ uint8 map_calc_dir(struct block_list *src, int x, int y)
  *------------------------------------------*/
 int map_random_dir(struct block_list *bl, short *x, short *y)
 {
-    short xi = *x-bl->x;
-    short yi = *y-bl->y;
-    short i=0, j;
-    int dist2 = xi*xi + yi*yi;
-    short dist = (short)sqrt((float)dist2);
-    short segment;
-
-    if (dist < 1) dist =1;
-
-    do {
-        j = 1 + 2*(rnd()%4); //Pick a random diagonal direction
-        segment = 1+(rnd()%dist); //Pick a random interval from the whole vector in that direction
-        xi = bl->x + segment*dirx[j];
-        segment = (short)sqrt((float)(dist2 - segment*segment)); //The complement of the previously picked segment
-        yi = bl->y + segment*diry[j];
-    } while (
-        (map_getcell(bl->m,xi,yi,CELL_CHKNOPASS) || !path_search(NULL,bl->m,bl->x,bl->y,xi,yi,1,CELL_CHKNOREACH))
-        && (++i)<100);
-
-    if (i < 100) {
-        *x = xi;
-        *y = yi;
-        return 1;
-    }
-    return 0;
+	short xi = *x-bl->x;
+	short yi = *y-bl->y;
+	short i=0, j;
+	int dist2 = xi*xi + yi*yi;
+	short dist = (short)sqrt((float)dist2);
+	short segment;
+
+	if (dist < 1) dist =1;
+
+	do {
+		j = 1 + 2*(rnd()%4); //Pick a random diagonal direction
+		segment = 1+(rnd()%dist); //Pick a random interval from the whole vector in that direction
+		xi = bl->x + segment*dirx[j];
+		segment = (short)sqrt((float)(dist2 - segment*segment)); //The complement of the previously picked segment
+		yi = bl->y + segment*diry[j];
+	} while (
+		(map_getcell(bl->m,xi,yi,CELL_CHKNOPASS) || !path_search(NULL,bl->m,bl->x,bl->y,xi,yi,1,CELL_CHKNOREACH))
+		&& (++i)<100 );
+
+	if (i < 100) {
+		*x = xi;
+		*y = yi;
+		return 1;
+	}
+	return 0;
 }
 
 // gat system
 inline static struct mapcell map_gat2cell(int gat) {
-    struct mapcell cell;
-
-    memset(&cell,0,sizeof(struct mapcell));
-
-    switch (gat) {
-        case 0:
-            cell.walkable = 1;
-            cell.shootable = 1;
-            cell.water = 0;
-            break; // walkable ground
-        case 1:
-            cell.walkable = 0;
-            cell.shootable = 0;
-            cell.water = 0;
-            break; // non-walkable ground
-        case 2:
-            cell.walkable = 1;
-            cell.shootable = 1;
-            cell.water = 0;
-            break; // ???
-        case 3:
-            cell.walkable = 1;
-            cell.shootable = 1;
-            cell.water = 1;
-            break; // walkable water
-        case 4:
-            cell.walkable = 1;
-            cell.shootable = 1;
-            cell.water = 0;
-            break; // ???
-        case 5:
-            cell.walkable = 0;
-            cell.shootable = 1;
-            cell.water = 0;
-            break; // gap (snipable)
-        case 6:
-            cell.walkable = 1;
-            cell.shootable = 1;
-            cell.water = 0;
-            break; // ???
-        default:
-            ShowWarning("map_gat2cell: unrecognized gat type '%d'\n", gat);
-            break;
-    }
-
-    return cell;
+	struct mapcell cell;
+
+	memset(&cell,0,sizeof(struct mapcell));
+
+	switch( gat ) {
+		case 0: cell.walkable = 1; cell.shootable = 1; cell.water = 0; break; // walkable ground
+		case 1: cell.walkable = 0; cell.shootable = 0; cell.water = 0; break; // non-walkable ground
+		case 2: cell.walkable = 1; cell.shootable = 1; cell.water = 0; break; // ???
+		case 3: cell.walkable = 1; cell.shootable = 1; cell.water = 1; break; // walkable water
+		case 4: cell.walkable = 1; cell.shootable = 1; cell.water = 0; break; // ???
+		case 5: cell.walkable = 0; cell.shootable = 1; cell.water = 0; break; // gap (snipable)
+		case 6: cell.walkable = 1; cell.shootable = 1; cell.water = 0; break; // ???
+		default:
+			ShowWarning("map_gat2cell: unrecognized gat type '%d'\n", gat);
+			break;
+	}
+
+	return cell;
 }
 
 static int map_cell2gat(struct mapcell cell)
 {
-    if (cell.walkable == 1 && cell.shootable == 1 && cell.water == 0) return 0;
-    if (cell.walkable == 0 && cell.shootable == 0 && cell.water == 0) return 1;
-    if (cell.walkable == 1 && cell.shootable == 1 && cell.water == 1) return 3;
-    if (cell.walkable == 0 && cell.shootable == 1 && cell.water == 0) return 5;
+	if( cell.walkable == 1 && cell.shootable == 1 && cell.water == 0 ) return 0;
+	if( cell.walkable == 0 && cell.shootable == 0 && cell.water == 0 ) return 1;
+	if( cell.walkable == 1 && cell.shootable == 1 && cell.water == 1 ) return 3;
+	if( cell.walkable == 0 && cell.shootable == 1 && cell.water == 0 ) return 5;
 
-    ShowWarning("map_cell2gat: cell has no matching gat type\n");
-    return 1; // default to 'wall'
+	ShowWarning("map_cell2gat: cell has no matching gat type\n");
+	return 1; // default to 'wall'
 }
 
 /*==========================================
@@ -2443,78 +2453,79 @@ static int map_cell2gat(struct mapcell cell)
  *------------------------------------------*/
 int map_getcell(int m,int x,int y,cell_chk cellchk)
 {
-    return (m < 0 || m >= MAX_MAP_PER_SERVER) ? 0 : map_getcellp(&map[m],x,y,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,int x,int y,cell_chk cellchk)
 {
-    struct mapcell cell;
+	struct mapcell cell;
 
-    nullpo_ret(m);
+	nullpo_ret(m);
 
-    //NOTE: this intentionally overrides the last row and column
-    if (x<0 || x>=m->xs-1 || y<0 || y>=m->ys-1)
-        return(cellchk == CELL_CHKNOPASS);
+	//NOTE: this intentionally overrides the last row and column
+	if(x<0 || x>=m->xs-1 || y<0 || y>=m->ys-1)
+		return( cellchk == CELL_CHKNOPASS );
 
-    cell = m->cell[x + y*m->xs];
+	cell = m->cell[x + y*m->xs];
 
-    switch (cellchk) {
-            // gat type retrieval
-        case CELL_GETTYPE:
-            return map_cell2gat(cell);
+	switch(cellchk)
+	{
+		// gat type retrieval
+		case CELL_GETTYPE:
+			return map_cell2gat(cell);
 
-            // base gat type checks
-        case CELL_CHKWALL:
-            return (!cell.walkable && !cell.shootable);
+		// base gat type checks
+		case CELL_CHKWALL:
+			return (!cell.walkable && !cell.shootable);
 
-        case CELL_CHKWATER:
-            return (cell.water);
+		case CELL_CHKWATER:
+			return (cell.water);
 
-        case CELL_CHKCLIFF:
-            return (!cell.walkable && cell.shootable);
+		case CELL_CHKCLIFF:
+			return (!cell.walkable && cell.shootable);
 
 
-            // base cell type checks
-        case CELL_CHKNPC:
-            return (cell.npc);
-        case CELL_CHKBASILICA:
-            return (cell.basilica);
-        case CELL_CHKLANDPROTECTOR:
-            return (cell.landprotector);
-        case CELL_CHKNOVENDING:
-            return (cell.novending);
-        case CELL_CHKNOCHAT:
-            return (cell.nochat);
-        case CELL_CHKMAELSTROM:
-            return (cell.maelstrom);
-        case CELL_CHKICEWALL:
-            return (cell.icewall);
+		// base cell type checks
+		case CELL_CHKNPC:
+			return (cell.npc);
+		case CELL_CHKBASILICA:
+			return (cell.basilica);
+		case CELL_CHKLANDPROTECTOR:
+			return (cell.landprotector);
+		case CELL_CHKNOVENDING:
+			return (cell.novending);
+		case CELL_CHKNOCHAT:
+			return (cell.nochat);
+		case CELL_CHKMAELSTROM:
+			return (cell.maelstrom);
+		case CELL_CHKICEWALL:
+			return (cell.icewall);
 
-            // special checks
-        case CELL_CHKPASS:
+		// special checks
+		case CELL_CHKPASS:
 #ifdef CELL_NOSTACK
-            if (cell.cell_bl >= battle_config.cell_stack_limit) return 0;
+			if (cell.cell_bl >= battle_config.cell_stack_limit) return 0;
 #endif
-        case CELL_CHKREACH:
-            return (cell.walkable);
+		case CELL_CHKREACH:
+			return (cell.walkable);
 
-        case CELL_CHKNOPASS:
+		case CELL_CHKNOPASS:
 #ifdef CELL_NOSTACK
-            if (cell.cell_bl >= battle_config.cell_stack_limit) return 1;
+			if (cell.cell_bl >= battle_config.cell_stack_limit) return 1;
 #endif
-        case CELL_CHKNOREACH:
-            return (!cell.walkable);
+		case CELL_CHKNOREACH:
+			return (!cell.walkable);
 
-        case CELL_CHKSTACK:
+		case CELL_CHKSTACK:
 #ifdef CELL_NOSTACK
-            return (cell.cell_bl >= battle_config.cell_stack_limit);
+			return (cell.cell_bl >= battle_config.cell_stack_limit);
 #else
-            return 0;
+			return 0;
 #endif
 
-        default:
-            return 0;
-    }
+		default:
+			return 0;
+	}
 }
 
 /*==========================================
@@ -2524,174 +2535,158 @@ int map_getcellp(struct map_data *m,int x,int y,cell_chk cellchk)
  *------------------------------------------*/
 void map_setcell(int m, int x, int y, cell_t cell, bool flag)
 {
-    int j;
-
-    if (m < 0 || m >= map_num || x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys)
-        return;
-
-    j = x + y*map[m].xs;
-
-    switch (cell) {
-        case CELL_WALKABLE:
-            map[m].cell[j].walkable = flag;
-            break;
-        case CELL_SHOOTABLE:
-            map[m].cell[j].shootable = flag;
-            break;
-        case CELL_WATER:
-            map[m].cell[j].water = flag;
-            break;
-
-        case CELL_NPC:
-            map[m].cell[j].npc = flag;
-            break;
-        case CELL_BASILICA:
-            map[m].cell[j].basilica = flag;
-            break;
-        case CELL_LANDPROTECTOR:
-            map[m].cell[j].landprotector = flag;
-            break;
-        case CELL_NOVENDING:
-            map[m].cell[j].novending = flag;
-            break;
-        case CELL_NOCHAT:
-            map[m].cell[j].nochat = flag;
-            break;
-        case CELL_MAELSTROM:
-            map[m].cell[j].maelstrom = flag;
-            break;
-        case CELL_ICEWALL:
-            map[m].cell[j].icewall = flag;
-            break;
-        default:
-            ShowWarning("map_setcell: invalid cell type '%d'\n", (int)cell);
-            break;
-    }
+	int j;
+
+	if( m < 0 || m >= map_num || x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys )
+		return;
+
+	j = x + y*map[m].xs;
+
+	switch( cell ) {
+		case CELL_WALKABLE:      map[m].cell[j].walkable = flag;      break;
+		case CELL_SHOOTABLE:     map[m].cell[j].shootable = flag;     break;
+		case CELL_WATER:         map[m].cell[j].water = flag;         break;
+
+		case CELL_NPC:           map[m].cell[j].npc = flag;           break;
+		case CELL_BASILICA:      map[m].cell[j].basilica = flag;      break;
+		case CELL_LANDPROTECTOR: map[m].cell[j].landprotector = flag; break;
+		case CELL_NOVENDING:     map[m].cell[j].novending = flag;     break;
+		case CELL_NOCHAT:        map[m].cell[j].nochat = flag;        break;
+		case CELL_MAELSTROM:	 map[m].cell[j].maelstrom = flag;	  break;
+		case CELL_ICEWALL:		 map[m].cell[j].icewall = flag;		  break;
+		default:
+			ShowWarning("map_setcell: invalid cell type '%d'\n", (int)cell);
+			break;
+	}
 }
 
 void map_setgatcell(int m, int x, int y, int gat)
 {
-    int j;
-    struct mapcell cell;
+	int j;
+	struct mapcell cell;
 
-    if (m < 0 || m >= map_num || x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys)
-        return;
+	if( m < 0 || m >= map_num || x < 0 || x >= map[m].xs || y < 0 || y >= map[m].ys )
+		return;
 
-    j = x + y*map[m].xs;
+	j = x + y*map[m].xs;
 
-    cell = map_gat2cell(gat);
-    map[m].cell[j].walkable = cell.walkable;
-    map[m].cell[j].shootable = cell.shootable;
-    map[m].cell[j].water = cell.water;
+	cell = map_gat2cell(gat);
+	map[m].cell[j].walkable = cell.walkable;
+	map[m].cell[j].shootable = cell.shootable;
+	map[m].cell[j].water = cell.water;
 }
 
 /*==========================================
  * Invisible Walls
  *------------------------------------------*/
-static DBMap *iwall_db;
+static DBMap* iwall_db;
 
 void map_iwall_nextxy(int x, int y, int dir, int pos, int *x1, int *y1)
 {
-    if (dir == 0 || dir == 4)
-        *x1 = x; // Keep X
-    else if (dir > 0 && dir < 4)
-        *x1 = x - pos; // Going left
-    else
-        *x1 = x + pos; // Going right
+	if( dir == 0 || dir == 4 )
+		*x1 = x; // Keep X
+	else if( dir > 0 && dir < 4 )
+		*x1 = x - pos; // Going left
+	else
+		*x1 = x + pos; // Going right
 
-    if (dir == 2 || dir == 6)
-        *y1 = y;
-    else if (dir > 2 && dir < 6)
-        *y1 = y - pos;
-    else
-        *y1 = y + pos;
+	if( dir == 2 || dir == 6 )
+		*y1 = y;
+	else if( dir > 2 && dir < 6 )
+		*y1 = y - pos;
+	else
+		*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(int m, int x, int y, int size, int dir, bool shootable, const char* wall_name)
 {
-    struct iwall_data *iwall;
-    int i, x1 = 0, y1 = 0;
+	struct iwall_data *iwall;
+	int i, x1 = 0, y1 = 0;
 
-    if (size < 1 || !wall_name)
-        return false;
+	if( size < 1 || !wall_name )
+		return false;
 
-    if ((iwall = (struct iwall_data *)strdb_get(iwall_db, wall_name)) != NULL)
-        return false; // Already Exists
+	if( (iwall = (struct iwall_data *)strdb_get(iwall_db, wall_name)) != NULL )
+		return false; // Already Exists
 
-    if (map_getcell(m, x, y, CELL_CHKNOREACH))
-        return false; // Starting cell problem
+	if( map_getcell(m, x, y, CELL_CHKNOREACH) )
+		return false; // Starting cell problem
 
-    CREATE(iwall, struct iwall_data, 1);
-    iwall->m = m;
-    iwall->x = x;
-    iwall->y = y;
-    iwall->size = size;
-    iwall->dir = dir;
-    iwall->shootable = shootable;
-    safestrncpy(iwall->wall_name, wall_name, sizeof(iwall->wall_name));
+	CREATE(iwall, struct iwall_data, 1);
+	iwall->m = m;
+	iwall->x = x;
+	iwall->y = y;
+	iwall->size = size;
+	iwall->dir = dir;
+	iwall->shootable = shootable;
+	safestrncpy(iwall->wall_name, wall_name, sizeof(iwall->wall_name));
 
-    for (i = 0; i < size; i++) {
-        map_iwall_nextxy(x, y, dir, i, &x1, &y1);
+	for( i = 0; i < size; i++ )
+	{
+		map_iwall_nextxy(x, y, dir, i, &x1, &y1);
 
-        if (map_getcell(m, x1, y1, CELL_CHKNOREACH))
-            break; // Collision
+		if( map_getcell(m, x1, y1, CELL_CHKNOREACH) )
+			break; // Collision
 
-        map_setcell(m, x1, y1, CELL_WALKABLE, false);
-        map_setcell(m, x1, y1, CELL_SHOOTABLE, shootable);
+		map_setcell(m, x1, y1, CELL_WALKABLE, false);
+		map_setcell(m, x1, y1, CELL_SHOOTABLE, shootable);
 
-        clif_changemapcell(0, m, x1, y1, map_getcell(m, x1, y1, CELL_GETTYPE), ALL_SAMEMAP);
-    }
+		clif_changemapcell(0, m, x1, y1, map_getcell(m, x1, y1, CELL_GETTYPE), ALL_SAMEMAP);
+	}
 
-    iwall->size = i;
+	iwall->size = i;
 
-    strdb_put(iwall_db, iwall->wall_name, iwall);
-    map[m].iwall_num++;
+	strdb_put(iwall_db, iwall->wall_name, iwall);
+	map[m].iwall_num++;
 
-    return true;
+	return true;
 }
 
 void map_iwall_get(struct map_session_data *sd)
 {
-    struct iwall_data *iwall;
-    DBIterator *iter;
-    int x1, y1;
-    int i;
+	struct iwall_data *iwall;
+	DBIterator* iter;
+	int x1, y1;
+	int i;
 
-    if (map[sd->bl.m].iwall_num < 1)
-        return;
+	if( map[sd->bl.m].iwall_num < 1 )
+		return;
 
-    iter = db_iterator(iwall_db);
-    for (iwall = dbi_first(iter); dbi_exists(iter); iwall = dbi_next(iter)) {
-        if (iwall->m != sd->bl.m)
-            continue;
+	iter = db_iterator(iwall_db);
+	for( iwall = dbi_first(iter); dbi_exists(iter); iwall = dbi_next(iter) )
+	{
+		if( iwall->m != sd->bl.m )
+			continue;
 
-        for (i = 0; i < iwall->size; i++) {
-            map_iwall_nextxy(iwall->x, iwall->y, iwall->dir, i, &x1, &y1);
-            clif_changemapcell(sd->fd, iwall->m, x1, y1, map_getcell(iwall->m, x1, y1, CELL_GETTYPE), SELF);
-        }
-    }
-    dbi_destroy(iter);
+		for( i = 0; i < iwall->size; i++ )
+		{
+			map_iwall_nextxy(iwall->x, iwall->y, iwall->dir, i, &x1, &y1);
+			clif_changemapcell(sd->fd, iwall->m, x1, y1, map_getcell(iwall->m, x1, y1, CELL_GETTYPE), SELF);
+		}
+	}
+	dbi_destroy(iter);
 }
 
 void map_iwall_remove(const char *wall_name)
 {
-    struct iwall_data *iwall;
-    int i, x1, y1;
+	struct iwall_data *iwall;
+	int i, x1, y1;
 
-    if ((iwall = (struct iwall_data *)strdb_get(iwall_db, wall_name)) == NULL)
-        return; // Nothing to do
+	if( (iwall = (struct iwall_data *)strdb_get(iwall_db, wall_name)) == NULL )
+		return; // Nothing to do
 
-    for (i = 0; i < iwall->size; i++) {
-        map_iwall_nextxy(iwall->x, iwall->y, iwall->dir, i, &x1, &y1);
+	for( i = 0; i < iwall->size; i++ )
+	{
+		map_iwall_nextxy(iwall->x, iwall->y, iwall->dir, i, &x1, &y1);
 
-        map_setcell(iwall->m, x1, y1, CELL_SHOOTABLE, true);
-        map_setcell(iwall->m, x1, y1, CELL_WALKABLE, true);
+		map_setcell(iwall->m, x1, y1, CELL_SHOOTABLE, true);
+		map_setcell(iwall->m, x1, y1, CELL_WALKABLE, true);
 
-        clif_changemapcell(0, iwall->m, x1, y1, map_getcell(iwall->m, x1, y1, CELL_GETTYPE), ALL_SAMEMAP);
-    }
+		clif_changemapcell(0, iwall->m, x1, y1, map_getcell(iwall->m, x1, y1, CELL_GETTYPE), ALL_SAMEMAP);
+	}
 
-    map[iwall->m].iwall_num--;
-    strdb_remove(iwall_db, iwall->wall_name);
+	map[iwall->m].iwall_num--;
+	strdb_remove(iwall_db, iwall->wall_name);
 }
 
 /**
@@ -2699,12 +2694,12 @@ void map_iwall_remove(const char *wall_name)
  */
 static DBData create_map_data_other_server(DBKey key, va_list args)
 {
-    struct map_data_other_server *mdos;
-    unsigned short mapindex = (unsigned short)key.ui;
-    mdos=(struct map_data_other_server *)aCalloc(1,sizeof(struct map_data_other_server));
-    mdos->index = mapindex;
-    memcpy(mdos->name, mapindex_id2name(mapindex), MAP_NAME_LENGTH);
-    return db_ptr2data(mdos);
+	struct map_data_other_server *mdos;
+	unsigned short mapindex = (unsigned short)key.ui;
+	mdos=(struct map_data_other_server *)aCalloc(1,sizeof(struct map_data_other_server));
+	mdos->index = mapindex;
+	memcpy(mdos->name, mapindex_id2name(mapindex), MAP_NAME_LENGTH);
+	return db_ptr2data(mdos);
 }
 
 /*==========================================
@@ -2712,20 +2707,20 @@ static DBData create_map_data_other_server(DBKey key, va_list args)
  *------------------------------------------*/
 int map_setipport(unsigned short mapindex, uint32 ip, uint16 port)
 {
-    struct map_data_other_server *mdos=NULL;
+	struct map_data_other_server *mdos=NULL;
 
-    mdos= uidb_ensure(map_db,(unsigned int)mapindex, create_map_data_other_server);
+	mdos= uidb_ensure(map_db,(unsigned int)mapindex, create_map_data_other_server);
 
-    if (mdos->cell) //Local map,Do nothing. Give priority to our own local maps over ones from another server. [Skotlex]
-        return 0;
-    if (ip == clif_getip() && port == clif_getport()) {
-        //That's odd, we received info that we are the ones with this map, but... we don't have it.
-        ShowFatalError("map_setipport : received info that this map-server SHOULD have map '%s', but it is not loaded.\n",mapindex_id2name(mapindex));
-        exit(EXIT_FAILURE);
-    }
-    mdos->ip   = ip;
-    mdos->port = port;
-    return 1;
+	if(mdos->cell) //Local map,Do nothing. Give priority to our own local maps over ones from another server. [Skotlex]
+		return 0;
+	if(ip == clif_getip() && port == clif_getport()) {
+		//That's odd, we received info that we are the ones with this map, but... we don't have it.
+		ShowFatalError("map_setipport : received info that this map-server SHOULD have map '%s', but it is not loaded.\n",mapindex_id2name(mapindex));
+		exit(EXIT_FAILURE);
+	}
+	mdos->ip   = ip;
+	mdos->port = port;
+	return 1;
 }
 
 /**
@@ -2734,18 +2729,18 @@ int map_setipport(unsigned short mapindex, uint32 ip, uint16 port)
  */
 int map_eraseallipport_sub(DBKey key, DBData *data, va_list va)
 {
-    struct map_data_other_server *mdos = db_data2ptr(data);
-    if (mdos->cell == NULL) {
-        db_remove(map_db,key);
-        aFree(mdos);
-    }
-    return 0;
+	struct map_data_other_server *mdos = db_data2ptr(data);
+	if(mdos->cell == NULL) {
+		db_remove(map_db,key);
+		aFree(mdos);
+	}
+	return 0;
 }
 
 int map_eraseallipport(void)
 {
-    map_db->foreach(map_db,map_eraseallipport_sub);
-    return 1;
+	map_db->foreach(map_db,map_eraseallipport_sub);
+	return 1;
 }
 
 /*==========================================
@@ -2753,18 +2748,18 @@ int map_eraseallipport(void)
  *------------------------------------------*/
 int map_eraseipport(unsigned short mapindex, uint32 ip, uint16 port)
 {
-    struct map_data_other_server *mdos;
+	struct map_data_other_server *mdos;
 
-    mdos = (struct map_data_other_server *)uidb_get(map_db,(unsigned int)mapindex);
-    if (!mdos || mdos->cell) //Map either does not exists or is a local map.
-        return 0;
+	mdos = (struct map_data_other_server*)uidb_get(map_db,(unsigned int)mapindex);
+	if(!mdos || mdos->cell) //Map either does not exists or is a local map.
+		return 0;
 
-    if (mdos->ip==ip && mdos->port == port) {
-        uidb_remove(map_db,(unsigned int)mapindex);
-        aFree(mdos);
-        return 1;
-    }
-    return 0;
+	if(mdos->ip==ip && mdos->port == port) {
+		uidb_remove(map_db,(unsigned int)mapindex);
+		aFree(mdos);
+		return 1;
+	}
+	return 0;
 }
 
 /*==========================================
@@ -2772,30 +2767,30 @@ int map_eraseipport(unsigned short mapindex, uint32 ip, uint16 port)
  *------------------------------------------*/
 static char *map_init_mapcache(FILE *fp)
 {
-    size_t size = 0;
-    char *buffer;
+	size_t size = 0;
+	char *buffer;
 
-    // No file open? Return..
-    nullpo_ret(fp);
+	// No file open? Return..
+	nullpo_ret(fp);
 
-    // Get file size
-    fseek(fp, 0, SEEK_END);
-    size = ftell(fp);
-    fseek(fp, 0, SEEK_SET);
+	// Get file size
+	fseek(fp, 0, SEEK_END);
+	size = ftell(fp);
+	fseek(fp, 0, SEEK_SET);
 
-    // Allocate enough space
-    CREATE(buffer, char, size);
+	// Allocate enough space
+	CREATE(buffer, char, size);
 
-    // No memory? Return..
-    nullpo_ret(buffer);
+	// No memory? Return..
+	nullpo_ret(buffer);
 
-    // Read file into buffer..
-    if (fread(buffer, sizeof(char), size, fp) != size) {
-        ShowError("map_init_mapcache: Could not read entire mapcache file\n");
-        return NULL;
-    }
+	// Read file into buffer..
+	if(fread(buffer, sizeof(char), size, fp) != size) {
+		ShowError("map_init_mapcache: Could not read entire mapcache file\n");
+		return NULL;
+	}
 
-    return buffer;
+	return buffer;
 }
 
 /*==========================================
@@ -2804,116 +2799,119 @@ static char *map_init_mapcache(FILE *fp)
  *==========================================*/
 int map_readfromcache(struct map_data *m, char *buffer, char *decode_buffer)
 {
-    int i;
-    struct map_cache_main_header *header = (struct map_cache_main_header *)buffer;
-    struct map_cache_map_info *info = NULL;
-    char *p = buffer + sizeof(struct map_cache_main_header);
+	int i;
+	struct map_cache_main_header *header = (struct map_cache_main_header *)buffer;
+	struct map_cache_map_info *info = NULL;
+	char *p = buffer + sizeof(struct map_cache_main_header);
 
-    for (i = 0; i < header->map_count; i++) {
-        info = (struct map_cache_map_info *)p;
+	for(i = 0; i < header->map_count; i++) {
+		info = (struct map_cache_map_info *)p;
 
-        if (strcmp(m->name, info->name) == 0)
-            break; // Map found
+		if( strcmp(m->name, info->name) == 0 )
+			break; // Map found
 
-        // Jump to next entry..
-        p += sizeof(struct map_cache_map_info) + info->len;
-    }
+		// Jump to next entry..
+		p += sizeof(struct map_cache_map_info) + info->len;
+	}
 
-    if (info && i < header->map_count) {
-        unsigned long size, xy;
+	if( info && i < header->map_count ) {
+		unsigned long size, xy;
 
-        if (info->xs <= 0 || info->ys <= 0)
-            return 0;// Invalid
+		if( info->xs <= 0 || info->ys <= 0 )
+			return 0;// Invalid
 
-        m->xs = info->xs;
-        m->ys = info->ys;
-        size = (unsigned long)info->xs*(unsigned long)info->ys;
+		m->xs = info->xs;
+		m->ys = info->ys;
+		size = (unsigned long)info->xs*(unsigned long)info->ys;
 
-        if (size > MAX_MAP_SIZE) {
-            ShowWarning("map_readfromcache: %s exceeded MAX_MAP_SIZE of %d\n", info->name, MAX_MAP_SIZE);
-            return 0; // Say not found to remove it from list.. [Shinryo]
-        }
+		if(size > MAX_MAP_SIZE) {
+			ShowWarning("map_readfromcache: %s exceeded MAX_MAP_SIZE of %d\n", info->name, MAX_MAP_SIZE);
+			return 0; // Say not found to remove it from list.. [Shinryo]
+		}
 
-        // TO-DO: Maybe handle the scenario, if the decoded buffer isn't the same size as expected? [Shinryo]
-        decode_zip(decode_buffer, &size, p+sizeof(struct map_cache_map_info), info->len);
+		// TO-DO: Maybe handle the scenario, if the decoded buffer isn't the same size as expected? [Shinryo]
+		decode_zip(decode_buffer, &size, p+sizeof(struct map_cache_map_info), info->len);
 
-        CREATE(m->cell, struct mapcell, size);
+		CREATE(m->cell, struct mapcell, size);
 
 
-        for (xy = 0; xy < size; ++xy)
-            m->cell[xy] = map_gat2cell(decode_buffer[xy]);
+		for( xy = 0; xy < size; ++xy )
+			m->cell[xy] = map_gat2cell(decode_buffer[xy]);
 
-        return 1;
-    }
+		return 1;
+	}
 
-    return 0; // Not found
+	return 0; // Not found
 }
 
-int map_addmap(char *mapname)
+int map_addmap(char* mapname)
 {
-    if (strcmpi(mapname,"clear")==0) {
-        map_num = 0;
-        instance_start = 0;
-        return 0;
-    }
+	if( strcmpi(mapname,"clear")==0 )
+	{
+		map_num = 0;
+		instance_start = 0;
+		return 0;
+	}
 
-    if (map_num >= MAX_MAP_PER_SERVER - 1) {
-        ShowError("Could not add map '"CL_WHITE"%s"CL_RESET"', the limit of maps has been reached.\n",mapname);
-        return 1;
-    }
+	if( map_num >= MAX_MAP_PER_SERVER - 1 )
+	{
+		ShowError("Could not add map '"CL_WHITE"%s"CL_RESET"', the limit of maps has been reached.\n",mapname);
+		return 1;
+	}
 
-    mapindex_getmapname(mapname, map[map_num].name);
-    map_num++;
-    return 0;
+	mapindex_getmapname(mapname, map[map_num].name);
+	map_num++;
+	return 0;
 }
 
 static void map_delmapid(int id)
 {
-    ShowNotice("Removing map [ %s ] from maplist"CL_CLL"\n",map[id].name);
-    memmove(map+id, map+id+1, sizeof(map[0])*(map_num-id-1));
-    map_num--;
+	ShowNotice("Removing map [ %s ] from maplist"CL_CLL"\n",map[id].name);
+	memmove(map+id, map+id+1, sizeof(map[0])*(map_num-id-1));
+	map_num--;
 }
 
-int map_delmap(char *mapname)
+int map_delmap(char* mapname)
 {
-    int i;
-    char map_name[MAP_NAME_LENGTH];
+	int i;
+	char map_name[MAP_NAME_LENGTH];
 
-    if (strcmpi(mapname, "all") == 0) {
-        map_num = 0;
-        return 0;
-    }
+	if (strcmpi(mapname, "all") == 0) {
+		map_num = 0;
+		return 0;
+	}
 
-    mapindex_getmapname(mapname, map_name);
-    for (i = 0; i < map_num; i++) {
-        if (strcmp(map[i].name, map_name) == 0) {
-            map_delmapid(i);
-            return 1;
-        }
-    }
-    return 0;
+	mapindex_getmapname(mapname, map_name);
+	for(i = 0; i < map_num; i++) {
+		if (strcmp(map[i].name, map_name) == 0) {
+			map_delmapid(i);
+			return 1;
+		}
+	}
+	return 0;
 }
 
 /// Initializes map flags and adjusts them depending on configuration.
 void map_flags_init(void)
 {
-    int i;
+	int i;
 
-    for (i = 0; i < map_num; i++) {
-        // mapflags
-        memset(&map[i].flag, 0, sizeof(map[i].flag));
+	for( i = 0; i < map_num; i++ )
+	{
+		// mapflags
+		memset(&map[i].flag, 0, sizeof(map[i].flag));
 
-        // additional mapflag data
-        map[i].zone      = 0;  // restricted mapflag zone
-        map[i].nocommand = 0;  // nocommand mapflag level
-        map[i].bexp      = 100;  // per map base exp multiplicator
-        map[i].jexp      = 100;  // per map job exp multiplicator
-        memset(map[i].drop_list, 0, sizeof(map[i].drop_list));  // pvp nightmare drop list
+		// additional mapflag data
+		map[i].zone      = 0;  // restricted mapflag zone
+		map[i].nocommand = 0;  // nocommand mapflag level
+		map[i].bexp      = 100;  // per map base exp multiplicator
+		map[i].jexp      = 100;  // per map job exp multiplicator
+		memset(map[i].drop_list, 0, sizeof(map[i].drop_list));  // pvp nightmare drop list
 
-        // adjustments
-        if (battle_config.pk_mode)
-            map[i].flag.pvp = 1; // make all maps pvp for pk_mode [Valaris]
-    }
+		// adjustments
+		if( battle_config.pk_mode )
+			map[i].flag.pvp = 1; // make all maps pvp for pk_mode [Valaris]
+	}
 }
 
 #define NO_WATER 1000000
@@ -2924,69 +2922,70 @@ void map_flags_init(void)
  * Assumed path for file is data/mapname.rsw
  * Credits to LittleWolf
  */
-int map_waterheight(char *mapname)
+int map_waterheight(char* mapname)
 {
-    char fn[256];
-    char *rsw, *found;
+	char fn[256];
+ 	char *rsw, *found;
 
-    //Look up for the rsw
-    sprintf(fn, "data\\%s.rsw", mapname);
+	//Look up for the rsw
+	sprintf(fn, "data\\%s.rsw", mapname);
 
-    found = grfio_find_file(fn);
-    if (found) strcpy(fn, found); // replace with real name
+	found = grfio_find_file(fn);
+	if (found) strcpy(fn, found); // replace with real name
 
-    // read & convert fn
-    rsw = (char *) grfio_read(fn);
-    if (rsw) {
-        //Load water height from file
-        int wh = (int) *(float *)(rsw+166);
-        aFree(rsw);
-        return wh;
-    }
-    ShowWarning("Failed to find water level for (%s)\n", mapname, fn);
-    return NO_WATER;
+	// read & convert fn
+	rsw = (char *) grfio_read (fn);
+	if (rsw)
+	{	//Load water height from file
+		int wh = (int) *(float*)(rsw+166);
+		aFree(rsw);
+		return wh;
+	}
+	ShowWarning("Failed to find water level for (%s)\n", mapname, fn);
+	return NO_WATER;
 }
 
 /*==================================
  * .GAT format
  *----------------------------------*/
-int map_readgat(struct map_data *m)
+int map_readgat (struct map_data* m)
 {
-    char filename[256];
-    uint8 *gat;
-    int water_height;
-    size_t xy, off, num_cells;
+	char filename[256];
+	uint8* gat;
+	int water_height;
+	size_t xy, off, num_cells;
 
-    sprintf(filename, "data\\%s.gat", m->name);
+	sprintf(filename, "data\\%s.gat", m->name);
 
-    gat = (uint8 *) grfio_read(filename);
-    if (gat == NULL)
-        return 0;
+	gat = (uint8 *) grfio_read(filename);
+	if (gat == NULL)
+		return 0;
 
-    m->xs = *(int32 *)(gat+6);
-    m->ys = *(int32 *)(gat+10);
-    num_cells = m->xs * m->ys;
-    CREATE(m->cell, struct mapcell, num_cells);
+	m->xs = *(int32*)(gat+6);
+	m->ys = *(int32*)(gat+10);
+	num_cells = m->xs * m->ys;
+	CREATE(m->cell, struct mapcell, num_cells);
 
-    water_height = map_waterheight(m->name);
+	water_height = map_waterheight(m->name);
 
-    // Set cell properties
-    off = 14;
-    for (xy = 0; xy < num_cells; ++xy) {
-        // read cell data
-        float height = *(float *)(gat + off);
-        uint32 type = *(uint32 *)(gat + off + 16);
-        off += 20;
+	// Set cell properties
+	off = 14;
+	for( xy = 0; xy < num_cells; ++xy )
+	{
+		// read cell data
+		float height = *(float*)( gat + off      );
+		uint32 type = *(uint32*)( gat + off + 16 );
+		off += 20;
 
-        if (type == 0 && water_height != NO_WATER && height > water_height)
-            type = 3; // Cell is 0 (walkable) but under water level, set to 3 (walkable water)
+		if( type == 0 && water_height != NO_WATER && height > water_height )
+			type = 3; // Cell is 0 (walkable) but under water level, set to 3 (walkable water)
 
-        m->cell[xy] = map_gat2cell(type);
-    }
+		m->cell[xy] = map_gat2cell(type);
+	}
 
-    aFree(gat);
+	aFree(gat);
 
-    return 1;
+	return 1;
 }
 
 /*======================================
@@ -2994,109 +2993,110 @@ int map_readgat(struct map_data *m)
  *--------------------------------------*/
 void map_addmap2db(struct map_data *m)
 {
-    uidb_put(map_db, (unsigned int)m->index, m);
+	uidb_put(map_db, (unsigned int)m->index, m);
 }
 
 void map_removemapdb(struct map_data *m)
 {
-    uidb_remove(map_db, (unsigned int)m->index);
+	uidb_remove(map_db, (unsigned int)m->index);
 }
 
 /*======================================
  * Initiate maps loading stage
  *--------------------------------------*/
-int map_readallmaps(void)
-{
-    int i;
-    FILE *fp=NULL;
-    int maps_removed = 0;
-    char *map_cache_buffer = NULL; // Has the uncompressed gat data of all maps, so just one allocation has to be made
-    char map_cache_decode_buffer[MAX_MAP_SIZE];
-
-    if (enable_grf)
-        ShowStatus("Loading maps (using GRF files)...\n");
-    else {
-        char mapcachefilepath[254];
-        sprintf(mapcachefilepath,"%s/%s%s",db_path,DBPATH,"map_cache.dat");
-        ShowStatus("Loading maps (using %s as map cache)...\n", mapcachefilepath);
-        if ((fp = fopen(mapcachefilepath, "rb")) == NULL) {
-            ShowFatalError("Unable to open map cache file "CL_WHITE"%s"CL_RESET"\n", mapcachefilepath);
-            exit(EXIT_FAILURE); //No use launching server if maps can't be read.
-        }
-
-        // Init mapcache data.. [Shinryo]
-        map_cache_buffer = map_init_mapcache(fp);
-        if (!map_cache_buffer) {
-            ShowFatalError("Failed to initialize mapcache data (%s)..\n", mapcachefilepath);
-            exit(EXIT_FAILURE);
-        }
-    }
-
-    for (i = 0; i < map_num; i++) {
-        size_t size;
-
-        // show progress
-        if (enable_grf)
-            ShowStatus("Loading maps [%i/%i]: %s"CL_CLL"\r", i, map_num, map[i].name);
-
-        // try to load the map
-        if (!
-            (enable_grf?
-             map_readgat(&map[i])
-             :map_readfromcache(&map[i], map_cache_buffer, map_cache_decode_buffer))
-           ) {
-            map_delmapid(i);
-            maps_removed++;
-            i--;
-            continue;
-        }
-
-        map[i].index = mapindex_name2id(map[i].name);
-
-        if (uidb_get(map_db,(unsigned int)map[i].index) != NULL) {
-            ShowWarning("Map %s already loaded!"CL_CLL"\n", map[i].name);
-            if (map[i].cell) {
-                aFree(map[i].cell);
-                map[i].cell = NULL;
-            }
-            map_delmapid(i);
-            maps_removed++;
-            i--;
-            continue;
-        }
-
-        map_addmap2db(&map[i]);
-
-        map[i].m = i;
-        memset(map[i].moblist, 0, sizeof(map[i].moblist));  //Initialize moblist [Skotlex]
-        map[i].mob_delete_timer = INVALID_TIMER;    //Initialize timer [Skotlex]
-
-        map[i].bxs = (map[i].xs + BLOCK_SIZE - 1) / BLOCK_SIZE;
-        map[i].bys = (map[i].ys + BLOCK_SIZE - 1) / BLOCK_SIZE;
-
-        size = map[i].bxs * map[i].bys * sizeof(struct block_list *);
-        map[i].block = (struct block_list **)aCalloc(size, 1);
-        map[i].block_mob = (struct block_list **)aCalloc(size, 1);
-    }
-
-    // intialization and configuration-dependent adjustments of mapflags
-    map_flags_init();
-
-    if (!enable_grf) {
-        fclose(fp);
-
-        // The cache isn't needed anymore, so free it.. [Shinryo]
-        aFree(map_cache_buffer);
-    }
-
-    // finished map loading
-    ShowInfo("Successfully loaded '"CL_WHITE"%d"CL_RESET"' maps."CL_CLL"\n",map_num);
-    instance_start = map_num; // Next Map Index will be instances
-
-    if (maps_removed)
-        ShowNotice("Maps removed: '"CL_WHITE"%d"CL_RESET"'\n",maps_removed);
-
-    return 0;
+int map_readallmaps (void)
+{
+	int i;
+	FILE* fp=NULL;
+	int maps_removed = 0;
+	char *map_cache_buffer = NULL; // Has the uncompressed gat data of all maps, so just one allocation has to be made
+	char map_cache_decode_buffer[MAX_MAP_SIZE];
+
+	if( enable_grf )
+		ShowStatus("Loading maps (using GRF files)...\n");
+	else {
+		char mapcachefilepath[254];
+		sprintf(mapcachefilepath,"%s/%s%s",db_path,DBPATH,"map_cache.dat");
+		ShowStatus("Loading maps (using %s as map cache)...\n", mapcachefilepath);
+		if( (fp = fopen(mapcachefilepath, "rb")) == NULL ) {
+			ShowFatalError("Unable to open map cache file "CL_WHITE"%s"CL_RESET"\n", mapcachefilepath);
+			exit(EXIT_FAILURE); //No use launching server if maps can't be read.
+		}
+
+		// Init mapcache data.. [Shinryo]
+		map_cache_buffer = map_init_mapcache(fp);
+		if(!map_cache_buffer) {
+			ShowFatalError("Failed to initialize mapcache data (%s)..\n", mapcachefilepath);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	for(i = 0; i < map_num; i++) {
+		size_t size;
+
+		// show progress
+		if(enable_grf)
+			ShowStatus("Loading maps [%i/%i]: %s"CL_CLL"\r", i, map_num, map[i].name);
+
+		// try to load the map
+		if( !
+			(enable_grf?
+				 map_readgat(&map[i])
+				:map_readfromcache(&map[i], map_cache_buffer, map_cache_decode_buffer))
+			) {
+			map_delmapid(i);
+			maps_removed++;
+			i--;
+			continue;
+		}
+
+		map[i].index = mapindex_name2id(map[i].name);
+
+		if (uidb_get(map_db,(unsigned int)map[i].index) != NULL)
+		{
+			ShowWarning("Map %s already loaded!"CL_CLL"\n", map[i].name);
+			if (map[i].cell) {
+				aFree(map[i].cell);
+				map[i].cell = NULL;
+			}
+			map_delmapid(i);
+			maps_removed++;
+			i--;
+			continue;
+		}
+
+		map_addmap2db(&map[i]);
+
+		map[i].m = i;
+		memset(map[i].moblist, 0, sizeof(map[i].moblist));	//Initialize moblist [Skotlex]
+		map[i].mob_delete_timer = INVALID_TIMER;	//Initialize timer [Skotlex]
+
+		map[i].bxs = (map[i].xs + BLOCK_SIZE - 1) / BLOCK_SIZE;
+		map[i].bys = (map[i].ys + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+		size = map[i].bxs * map[i].bys * sizeof(struct block_list*);
+		map[i].block = (struct block_list**)aCalloc(size, 1);
+		map[i].block_mob = (struct block_list**)aCalloc(size, 1);
+	}
+
+	// intialization and configuration-dependent adjustments of mapflags
+	map_flags_init();
+
+	if( !enable_grf ) {
+		fclose(fp);
+
+		// The cache isn't needed anymore, so free it.. [Shinryo]
+		aFree(map_cache_buffer);
+	}
+
+	// finished map loading
+	ShowInfo("Successfully loaded '"CL_WHITE"%d"CL_RESET"' maps."CL_CLL"\n",map_num);
+	instance_start = map_num; // Next Map Index will be instances
+
+	if (maps_removed)
+		ShowNotice("Maps removed: '"CL_WHITE"%d"CL_RESET"'\n",maps_removed);
+
+	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -3106,67 +3106,79 @@ static int char_ip_set = 0;
 /*==========================================
  * Console Command Parser [Wizputer]
  *------------------------------------------*/
-int parse_console(const char *buf)
-{
-    char type[64];
-    char command[64];
-    char map[64];
-    int x = 0;
-    int y = 0;
-    int 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[^\n]", type, command)) < 2) {
-            n = sscanf(buf, "%63[^\n]", type);
-        }
-    }
-
-    if (n == 5) {
-        m = map_mapname2mapid(map);
-        if (m < 0) {
-            ShowWarning("Console: Unknown map.\n");
-            return 0;
-        }
-        sd.bl.m = m;
-        map_search_freecell(&sd.bl, m, &sd.bl.x, &sd.bl.y, -1, -1, 0);
-        if (x > 0)
-            sd.bl.x = x;
-        if (y > 0)
-            sd.bl.y = y;
-    } else {
-        map[0] = '\0';
-        if (n < 2)
-            command[0] = '\0';
-        if (n < 1)
-            type[0] = '\0';
-    }
-
-    ShowNotice("Type of command: '%s' || Command: '%s' || Map: '%s' Coords: %d %d\n", type, command, map, x, y);
-
-    if (n == 5 && strcmpi("admin",type) == 0) {
-        if (!is_atcommand(sd.fd, &sd, command, 0))
-            ShowInfo("Console: not atcommand\n");
-    } else if (n == 2 && strcmpi("server", type) == 0) {
-        if (strcmpi("shutdown", command) == 0 || strcmpi("exit", command) == 0 || strcmpi("quit", command) == 0) {
-            runflag = 0;
-        }
-    } else if (strcmpi("help", type) == 0) {
-        ShowInfo("To use GM commands:\n");
-        ShowInfo("  admin:<gm command>:<map of \"gm\"> <x> <y>\n");
-        ShowInfo("You can use any GM command that doesn't require the GM.\n");
-        ShowInfo("No using @item or @warp however you can use @charwarp\n");
-        ShowInfo("The <map of \"gm\"> <x> <y> is for commands that need coords of the GM\n");
-        ShowInfo("IE: @spawn\n");
-        ShowInfo("To shutdown the server:\n");
-        ShowInfo("  server:shutdown\n");
-    }
-
-    return 0;
+int parse_console(const char* buf)
+{
+	char type[64];
+	char command[64];
+	char map[64];
+	int x = 0;
+	int y = 0;
+	int 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[^\n]", type, command) ) < 2 )
+		{
+			n = sscanf(buf, "%63[^\n]", type);
+		}
+	}
+
+	if( n == 5 )
+	{
+		m = map_mapname2mapid(map);
+		if( m < 0 )
+		{
+			ShowWarning("Console: Unknown map.\n");
+			return 0;
+		}
+		sd.bl.m = m;
+		map_search_freecell(&sd.bl, m, &sd.bl.x, &sd.bl.y, -1, -1, 0);
+		if( x > 0 )
+			sd.bl.x = x;
+		if( y > 0 )
+			sd.bl.y = y;
+	}
+	else
+	{
+		map[0] = '\0';
+		if( n < 2 )
+			command[0] = '\0';
+		if( n < 1 )
+			type[0] = '\0';
+	}
+
+	ShowNotice("Type of command: '%s' || Command: '%s' || Map: '%s' Coords: %d %d\n", type, command, map, x, y);
+
+	if( n == 5 && strcmpi("admin",type) == 0 )
+	{
+		if( !is_atcommand(sd.fd, &sd, command, 0) )
+			ShowInfo("Console: not atcommand\n");
+	}
+	else if( n == 2 && strcmpi("server", type) == 0 )
+	{
+		if( strcmpi("shutdown", command) == 0 || strcmpi("exit", command) == 0 || strcmpi("quit", command) == 0 )
+		{
+			runflag = 0;
+		}
+	}
+	else if( strcmpi("help", type) == 0 )
+	{
+		ShowInfo("To use GM commands:\n");
+		ShowInfo("  admin:<gm command>:<map of \"gm\"> <x> <y>\n");
+		ShowInfo("You can use any GM command that doesn't require the GM.\n");
+		ShowInfo("No using @item or @warp however you can use @charwarp\n");
+		ShowInfo("The <map of \"gm\"> <x> <y> is for commands that need coords of the GM\n");
+		ShowInfo("IE: @spawn\n");
+		ShowInfo("To shutdown the server:\n");
+		ShowInfo("  server:shutdown\n");
+	}
+
+	return 0;
 }
 
 /*==========================================
@@ -3174,218 +3186,241 @@ int parse_console(const char *buf)
  *------------------------------------------*/
 int map_config_read(char *cfgName)
 {
-    char line[1024], w1[1024], w2[1024];
-    FILE *fp;
-
-    fp = fopen(cfgName,"r");
-    if (fp == NULL) {
-        ShowError("Map configuration file not found at: %s\n", cfgName);
-        return 1;
-    }
-
-    while (fgets(line, sizeof(line), fp)) {
-        char *ptr;
-
-        if (line[0] == '/' && line[1] == '/')
-            continue;
-        if ((ptr = strstr(line, "//")) != NULL)
-            *ptr = '\n'; //Strip comments
-        if (sscanf(line, "%[^:]: %[^\t\r\n]", w1, w2) < 2)
-            continue;
-
-        //Strip trailing spaces
-        ptr = w2 + strlen(w2);
-        while (--ptr >= w2 && *ptr == ' ');
-        ptr++;
-        *ptr = '\0';
-
-        if (strcmpi(w1,"timestamp_format")==0)
-            strncpy(timestamp_format, w2, 20);
-        else if (strcmpi(w1,"stdout_with_ansisequence")==0)
-            stdout_with_ansisequence = config_switch(w2);
-        else if (strcmpi(w1,"console_silent")==0) {
-            msg_silent = atoi(w2);
-            if (msg_silent)  // only bother if its actually enabled
-                ShowInfo("Console Silent Setting: %d\n", atoi(w2));
-        } else if (strcmpi(w1, "userid")==0)
-            chrif_setuserid(w2);
-        else if (strcmpi(w1, "passwd") == 0)
-            chrif_setpasswd(w2);
-        else if (strcmpi(w1, "char_ip") == 0)
-            char_ip_set = chrif_setip(w2);
-        else if (strcmpi(w1, "char_port") == 0)
-            chrif_setport(atoi(w2));
-        else if (strcmpi(w1, "map_ip") == 0)
-            map_ip_set = clif_setip(w2);
-        else if (strcmpi(w1, "bind_ip") == 0)
-            clif_setbindip(w2);
-        else if (strcmpi(w1, "map_port") == 0) {
-            clif_setport(atoi(w2));
-            map_port = (atoi(w2));
-        } else if (strcmpi(w1, "map") == 0)
-            map_addmap(w2);
-        else if (strcmpi(w1, "delmap") == 0)
-            map_delmap(w2);
-        else if (strcmpi(w1, "npc") == 0)
-            npc_addsrcfile(w2);
-        else if (strcmpi(w1, "delnpc") == 0)
-            npc_delsrcfile(w2);
-        else if (strcmpi(w1, "autosave_time") == 0) {
-            autosave_interval = atoi(w2);
-            if (autosave_interval < 1) //Revert to default saving.
-                autosave_interval = DEFAULT_AUTOSAVE_INTERVAL;
-            else
-                autosave_interval *= 1000; //Pass from sec to ms
-        } else if (strcmpi(w1, "minsave_time") == 0) {
-            minsave_interval= atoi(w2);
-            if (minsave_interval < 1)
-                minsave_interval = 1;
-        } else if (strcmpi(w1, "save_settings") == 0)
-            save_settings = atoi(w2);
-        else if (strcmpi(w1, "motd_txt") == 0)
-            strcpy(motd_txt, w2);
-        else if (strcmpi(w1, "help_txt") == 0)
-            strcpy(help_txt, w2);
-        else if (strcmpi(w1, "help2_txt") == 0)
-            strcpy(help2_txt, w2);
-        else if (strcmpi(w1, "charhelp_txt") == 0)
-            strcpy(charhelp_txt, w2);
-        else if (strcmpi(w1,"db_path") == 0)
-            strncpy(db_path,w2,255);
-        else if (strcmpi(w1, "console") == 0) {
-            console = config_switch(w2);
-            if (console)
-                ShowNotice("Console Commands are enabled.\n");
-        } else if (strcmpi(w1, "enable_spy") == 0)
-            enable_spy = config_switch(w2);
-        else if (strcmpi(w1, "use_grf") == 0)
-            enable_grf = config_switch(w2);
-        else if (strcmpi(w1, "console_msg_log") == 0)
-            console_msg_log = atoi(w2);//[Ind]
-        else if (strcmpi(w1, "import") == 0)
-            map_config_read(w2);
-        else
-            ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
-    }
-
-    fclose(fp);
-    return 0;
+	char line[1024], w1[1024], w2[1024];
+	FILE *fp;
+
+	fp = fopen(cfgName,"r");
+	if( fp == NULL )
+	{
+		ShowError("Map configuration file not found at: %s\n", cfgName);
+		return 1;
+	}
+
+	while( fgets(line, sizeof(line), fp) )
+	{
+		char* ptr;
+
+		if( line[0] == '/' && line[1] == '/' )
+			continue;
+		if( (ptr = strstr(line, "//")) != NULL )
+			*ptr = '\n'; //Strip comments
+		if( sscanf(line, "%[^:]: %[^\t\r\n]", w1, w2) < 2 )
+			continue;
+
+		//Strip trailing spaces
+		ptr = w2 + strlen(w2);
+		while (--ptr >= w2 && *ptr == ' ');
+		ptr++;
+		*ptr = '\0';
+
+		if(strcmpi(w1,"timestamp_format")==0)
+			strncpy(timestamp_format, w2, 20);
+		else if(strcmpi(w1,"stdout_with_ansisequence")==0)
+			stdout_with_ansisequence = config_switch(w2);
+		else if(strcmpi(w1,"console_silent")==0) {
+			msg_silent = atoi(w2);
+			if( msg_silent ) // only bother if its actually enabled
+				ShowInfo("Console Silent Setting: %d\n", atoi(w2));
+		} else if (strcmpi(w1, "userid")==0)
+			chrif_setuserid(w2);
+		else if (strcmpi(w1, "passwd") == 0)
+			chrif_setpasswd(w2);
+		else if (strcmpi(w1, "char_ip") == 0)
+			char_ip_set = chrif_setip(w2);
+		else if (strcmpi(w1, "char_port") == 0)
+			chrif_setport(atoi(w2));
+		else if (strcmpi(w1, "map_ip") == 0)
+			map_ip_set = clif_setip(w2);
+		else if (strcmpi(w1, "bind_ip") == 0)
+			clif_setbindip(w2);
+		else if (strcmpi(w1, "map_port") == 0) {
+			clif_setport(atoi(w2));
+			map_port = (atoi(w2));
+		} else if (strcmpi(w1, "map") == 0)
+			map_addmap(w2);
+		else if (strcmpi(w1, "delmap") == 0)
+			map_delmap(w2);
+		else if (strcmpi(w1, "npc") == 0)
+			npc_addsrcfile(w2);
+		else if (strcmpi(w1, "delnpc") == 0)
+			npc_delsrcfile(w2);
+		else if (strcmpi(w1, "autosave_time") == 0) {
+			autosave_interval = atoi(w2);
+			if (autosave_interval < 1) //Revert to default saving.
+				autosave_interval = DEFAULT_AUTOSAVE_INTERVAL;
+			else
+				autosave_interval *= 1000; //Pass from sec to ms
+		} else if (strcmpi(w1, "minsave_time") == 0) {
+			minsave_interval= atoi(w2);
+			if (minsave_interval < 1)
+				minsave_interval = 1;
+		} else if (strcmpi(w1, "save_settings") == 0)
+			save_settings = atoi(w2);
+		else if (strcmpi(w1, "motd_txt") == 0)
+			strcpy(motd_txt, w2);
+		else if (strcmpi(w1, "help_txt") == 0)
+			strcpy(help_txt, w2);
+		else if (strcmpi(w1, "help2_txt") == 0)
+			strcpy(help2_txt, w2);
+		else if (strcmpi(w1, "charhelp_txt") == 0)
+			strcpy(charhelp_txt, w2);
+		else if(strcmpi(w1,"db_path") == 0)
+			strncpy(db_path,w2,255);
+		else if (strcmpi(w1, "console") == 0) {
+			console = config_switch(w2);
+			if (console)
+				ShowNotice("Console Commands are enabled.\n");
+		} else if (strcmpi(w1, "enable_spy") == 0)
+			enable_spy = config_switch(w2);
+		else if (strcmpi(w1, "use_grf") == 0)
+			enable_grf = config_switch(w2);
+		else if (strcmpi(w1, "console_msg_log") == 0)
+			console_msg_log = atoi(w2);//[Ind]
+		else if (strcmpi(w1, "import") == 0)
+			map_config_read(w2);
+		else
+			ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
+	}
+
+	fclose(fp);
+	return 0;
 }
 
 void map_reloadnpc_sub(char *cfgName)
 {
-    char line[1024], w1[1024], w2[1024];
-    FILE *fp;
+	char line[1024], w1[1024], w2[1024];
+	FILE *fp;
 
-    fp = fopen(cfgName,"r");
-    if (fp == NULL) {
-        ShowError("Map configuration file not found at: %s\n", cfgName);
-        return;
-    }
+	fp = fopen(cfgName,"r");
+	if( fp == NULL )
+	{
+		ShowError("Map configuration file not found at: %s\n", cfgName);
+		return;
+	}
 
-    while (fgets(line, sizeof(line), fp)) {
-        char *ptr;
+	while( fgets(line, sizeof(line), fp) )
+	{
+		char* ptr;
 
-        if (line[0] == '/' && line[1] == '/')
-            continue;
-        if ((ptr = strstr(line, "//")) != NULL)
-            *ptr = '\n'; //Strip comments
-        if (sscanf(line, "%[^:]: %[^\t\r\n]", w1, w2) < 2)
-            continue;
+		if( line[0] == '/' && line[1] == '/' )
+			continue;
+		if( (ptr = strstr(line, "//")) != NULL )
+			*ptr = '\n'; //Strip comments
+		if( sscanf(line, "%[^:]: %[^\t\r\n]", w1, w2) < 2 )
+			continue;
 
-        //Strip trailing spaces
-        ptr = w2 + strlen(w2);
-        while (--ptr >= w2 && *ptr == ' ');
-        ptr++;
-        *ptr = '\0';
+		//Strip trailing spaces
+		ptr = w2 + strlen(w2);
+		while (--ptr >= w2 && *ptr == ' ');
+		ptr++;
+		*ptr = '\0';
 
-        if (strcmpi(w1, "npc") == 0)
-            npc_addsrcfile(w2);
-        else if (strcmpi(w1, "import") == 0)
-            map_reloadnpc_sub(w2);
-        else
-            ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
-    }
+		if (strcmpi(w1, "npc") == 0)
+			npc_addsrcfile(w2);
+		else if (strcmpi(w1, "import") == 0)
+			map_reloadnpc_sub(w2);
+		else
+			ShowWarning("Unknown setting '%s' in file %s\n", w1, cfgName);
+	}
 
-    fclose(fp);
+	fclose(fp);
 }
 
 void map_reloadnpc(bool clear)
 {
-    if (clear)
-        npc_addsrcfile("clear"); // this will clear the current script list
+	if (clear)
+		npc_addsrcfile("clear"); // this will clear the current script list
 
 #ifdef RENEWAL
-    map_reloadnpc_sub("npc/re/scripts_main.conf");
+	map_reloadnpc_sub("npc/re/scripts_main.conf");
 #else
-    map_reloadnpc_sub("npc/pre-re/scripts_main.conf");
+	map_reloadnpc_sub("npc/pre-re/scripts_main.conf");
 #endif
 }
 
 int inter_config_read(char *cfgName)
 {
-    char line[1024],w1[1024],w2[1024];
-    FILE *fp;
-
-    fp=fopen(cfgName,"r");
-    if (fp==NULL) {
-        ShowError("File not found: %s\n",cfgName);
-        return 1;
-    }
-    while (fgets(line, sizeof(line), fp)) {
-        if (line[0] == '/' && line[1] == '/')
-            continue;
-        if (sscanf(line,"%[^:]: %[^\r\n]",w1,w2) < 2)
-            continue;
-
-        if (strcmpi(w1, "main_chat_nick")==0)
-            safestrncpy(main_chat_nick, w2, sizeof(main_chat_nick));
-        else if (strcmpi(w1,"item_db_db")==0)
-            strcpy(item_db_db,w2);
-        else if (strcmpi(w1,"mob_db_db")==0)
-            strcpy(mob_db_db,w2);
-        else if (strcmpi(w1,"item_db2_db")==0)
-            strcpy(item_db2_db,w2);
-        else if (strcmpi(w1,"item_db_re_db")==0)
-            strcpy(item_db_re_db,w2);
-        else if (strcmpi(w1,"mob_db2_db")==0)
-            strcpy(mob_db2_db,w2);
-        else
-            //Map Server SQL DB
-            if (strcmpi(w1,"map_server_ip")==0)
-                strcpy(map_server_ip, w2);
-            else if (strcmpi(w1,"map_server_port")==0)
-                map_server_port=atoi(w2);
-            else if (strcmpi(w1,"map_server_id")==0)
-                strcpy(map_server_id, w2);
-            else if (strcmpi(w1,"map_server_pw")==0)
-                strcpy(map_server_pw, w2);
-            else if (strcmpi(w1,"map_server_db")==0)
-                strcpy(map_server_db, w2);
-            else if (strcmpi(w1,"default_codepage")==0)
-                strcpy(default_codepage, w2);
-            else if (strcmpi(w1,"use_sql_db")==0) {
-                db_use_sqldbs = config_switch(w2);
-                ShowStatus("Using SQL dbs: %s\n",w2);
-            } else if (strcmpi(w1,"log_db_ip")==0)
-                strcpy(log_db_ip, w2);
-            else if (strcmpi(w1,"log_db_id")==0)
-                strcpy(log_db_id, w2);
-            else if (strcmpi(w1,"log_db_pw")==0)
-                strcpy(log_db_pw, w2);
-            else if (strcmpi(w1,"log_db_port")==0)
-                log_db_port = atoi(w2);
-            else if (strcmpi(w1,"log_db_db")==0)
-                strcpy(log_db_db, w2);
-            else if (mapreg_config_read(w1,w2))
-                continue;
-        //support the import command, just like any other config
-            else if (strcmpi(w1,"import")==0)
-                inter_config_read(w2);
-    }
-    fclose(fp);
-
-    return 0;
+	char line[1024],w1[1024],w2[1024];
+	FILE *fp;
+
+	fp=fopen(cfgName,"r");
+	if(fp==NULL){
+		ShowError("File not found: %s\n",cfgName);
+		return 1;
+	}
+	while(fgets(line, sizeof(line), fp))
+	{
+		if(line[0] == '/' && line[1] == '/')
+			continue;
+		if( sscanf(line,"%[^:]: %[^\r\n]",w1,w2) < 2 )
+			continue;
+
+		if(strcmpi(w1, "main_chat_nick")==0)
+			safestrncpy(main_chat_nick, w2, sizeof(main_chat_nick));
+		else
+		if(strcmpi(w1,"item_db_db")==0)
+			strcpy(item_db_db,w2);
+		else
+		if(strcmpi(w1,"mob_db_db")==0)
+			strcpy(mob_db_db,w2);
+		else
+		if(strcmpi(w1,"item_db2_db")==0)
+			strcpy(item_db2_db,w2);
+		else
+		if(strcmpi(w1,"item_db_re_db")==0)
+			strcpy(item_db_re_db,w2);
+		else
+		if(strcmpi(w1,"mob_db2_db")==0)
+			strcpy(mob_db2_db,w2);
+		else
+		//Map Server SQL DB
+		if(strcmpi(w1,"map_server_ip")==0)
+			strcpy(map_server_ip, w2);
+		else
+		if(strcmpi(w1,"map_server_port")==0)
+			map_server_port=atoi(w2);
+		else
+		if(strcmpi(w1,"map_server_id")==0)
+			strcpy(map_server_id, w2);
+		else
+		if(strcmpi(w1,"map_server_pw")==0)
+			strcpy(map_server_pw, w2);
+		else
+		if(strcmpi(w1,"map_server_db")==0)
+			strcpy(map_server_db, w2);
+		else
+		if(strcmpi(w1,"default_codepage")==0)
+			strcpy(default_codepage, w2);
+		else
+		if(strcmpi(w1,"use_sql_db")==0) {
+			db_use_sqldbs = config_switch(w2);
+			ShowStatus ("Using SQL dbs: %s\n",w2);
+		} else
+		if(strcmpi(w1,"log_db_ip")==0)
+			strcpy(log_db_ip, w2);
+		else
+		if(strcmpi(w1,"log_db_id")==0)
+			strcpy(log_db_id, w2);
+		else
+		if(strcmpi(w1,"log_db_pw")==0)
+			strcpy(log_db_pw, w2);
+		else
+		if(strcmpi(w1,"log_db_port")==0)
+			log_db_port = atoi(w2);
+		else
+		if(strcmpi(w1,"log_db_db")==0)
+			strcpy(log_db_db, w2);
+		else
+		if( mapreg_config_read(w1,w2) )
+			continue;
+		//support the import command, just like any other config
+		else
+		if(strcmpi(w1,"import")==0)
+			inter_config_read(w2);
+	}
+	fclose(fp);
+
+	return 0;
 }
 
 /*=======================================
@@ -3393,52 +3428,53 @@ int inter_config_read(char *cfgName)
  *---------------------------------------*/
 int map_sql_init(void)
 {
-    // main db connection
-    mmysql_handle = Sql_Malloc();
+	// main db connection
+	mmysql_handle = Sql_Malloc();
 
-    ShowInfo("Connecting to the Map DB Server....\n");
-    if (SQL_ERROR == Sql_Connect(mmysql_handle, map_server_id, map_server_pw, map_server_ip, map_server_port, map_server_db))
-        exit(EXIT_FAILURE);
-    ShowStatus("connect success! (Map Server Connection)\n");
+	ShowInfo("Connecting to the Map DB Server....\n");
+	if( SQL_ERROR == Sql_Connect(mmysql_handle, map_server_id, map_server_pw, map_server_ip, map_server_port, map_server_db) )
+		exit(EXIT_FAILURE);
+	ShowStatus("connect success! (Map Server Connection)\n");
 
-    if (strlen(default_codepage) > 0)
-        if (SQL_ERROR == Sql_SetEncoding(mmysql_handle, default_codepage))
-            Sql_ShowDebug(mmysql_handle);
+	if( strlen(default_codepage) > 0 )
+		if ( SQL_ERROR == Sql_SetEncoding(mmysql_handle, default_codepage) )
+			Sql_ShowDebug(mmysql_handle);
 
-    return 0;
+	return 0;
 }
 
 int map_sql_close(void)
 {
-    ShowStatus("Close Map DB Connection....\n");
-    Sql_Free(mmysql_handle);
-    mmysql_handle = NULL;
+	ShowStatus("Close Map DB Connection....\n");
+	Sql_Free(mmysql_handle);
+	mmysql_handle = NULL;
 #ifndef BETA_THREAD_TEST
-    if (log_config.sql_logs) {
-        ShowStatus("Close Log DB Connection....\n");
-        Sql_Free(logmysql_handle);
-        logmysql_handle = NULL;
-    }
+	if (log_config.sql_logs)
+	{
+		ShowStatus("Close Log DB Connection....\n");
+		Sql_Free(logmysql_handle);
+		logmysql_handle = NULL;
+	}
 #endif
-    return 0;
+	return 0;
 }
 
 int log_sql_init(void)
 {
 #ifndef BETA_THREAD_TEST
-    // log db connection
-    logmysql_handle = Sql_Malloc();
+	// log db connection
+	logmysql_handle = Sql_Malloc();
 
-    ShowInfo(""CL_WHITE"[SQL]"CL_RESET": Connecting to the Log Database "CL_WHITE"%s"CL_RESET" At "CL_WHITE"%s"CL_RESET"...\n",log_db_db,log_db_ip);
-    if (SQL_ERROR == Sql_Connect(logmysql_handle, log_db_id, log_db_pw, log_db_ip, log_db_port, log_db_db))
-        exit(EXIT_FAILURE);
-    ShowStatus(""CL_WHITE"[SQL]"CL_RESET": Successfully '"CL_GREEN"connected"CL_RESET"' to Database '"CL_WHITE"%s"CL_RESET"'.\n", log_db_db);
+	ShowInfo(""CL_WHITE"[SQL]"CL_RESET": Connecting to the Log Database "CL_WHITE"%s"CL_RESET" At "CL_WHITE"%s"CL_RESET"...\n",log_db_db,log_db_ip);
+	if ( SQL_ERROR == Sql_Connect(logmysql_handle, log_db_id, log_db_pw, log_db_ip, log_db_port, log_db_db) )
+		exit(EXIT_FAILURE);
+	ShowStatus(""CL_WHITE"[SQL]"CL_RESET": Successfully '"CL_GREEN"connected"CL_RESET"' to Database '"CL_WHITE"%s"CL_RESET"'.\n", log_db_db);
 
-    if (strlen(default_codepage) > 0)
-        if (SQL_ERROR == Sql_SetEncoding(logmysql_handle, default_codepage))
-            Sql_ShowDebug(logmysql_handle);
+	if( strlen(default_codepage) > 0 )
+		if ( SQL_ERROR == Sql_SetEncoding(logmysql_handle, default_codepage) )
+			Sql_ShowDebug(logmysql_handle);
 #endif
-    return 0;
+	return 0;
 }
 
 /**
@@ -3446,10 +3482,10 @@ int log_sql_init(void)
  */
 int map_db_final(DBKey key, DBData *data, va_list ap)
 {
-    struct map_data_other_server *mdos = db_data2ptr(data);
-    if (mdos && mdos->cell == NULL)
-        aFree(mdos);
-    return 0;
+	struct map_data_other_server *mdos = db_data2ptr(data);
+	if(mdos && mdos->cell == NULL)
+		aFree(mdos);
+	return 0;
 }
 
 /**
@@ -3457,46 +3493,47 @@ int map_db_final(DBKey key, DBData *data, va_list ap)
  */
 int nick_db_final(DBKey key, DBData *data, va_list args)
 {
-    struct charid2nick *p = db_data2ptr(data);
-    struct charid_request *req;
+	struct charid2nick* p = db_data2ptr(data);
+	struct charid_request* req;
 
-    if (p == NULL)
-        return 0;
-    while (p->requests) {
-        req = p->requests;
-        p->requests = req->next;
-        aFree(req);
-    }
-    aFree(p);
-    return 0;
+	if( p == NULL )
+		return 0;
+	while( p->requests )
+	{
+		req = p->requests;
+		p->requests = req->next;
+		aFree(req);
+	}
+	aFree(p);
+	return 0;
 }
 
 int 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);
-            break;
-        case BL_NPC:
-            npc_unload((struct npc_data *)bl,false);
-            break;
-        case BL_MOB:
-            unit_free(bl,CLR_OUTSIGHT);
-            break;
-        case BL_PET:
-            //There is no need for this, the pet is removed together with the player. [Skotlex]
-            break;
-        case BL_ITEM:
-            map_clearflooritem(bl);
-            break;
-        case BL_SKILL:
-            skill_delunit((struct skill_unit *) bl);
-            break;
-    }
-
-    return 1;
+	nullpo_ret(bl);
+
+	switch(bl->type) {
+		case BL_PC:
+			map_quit((struct map_session_data *) bl);
+			break;
+		case BL_NPC:
+			npc_unload((struct npc_data *)bl,false);
+			break;
+		case BL_MOB:
+			unit_free(bl,CLR_OUTSIGHT);
+			break;
+		case BL_PET:
+		//There is no need for this, the pet is removed together with the player. [Skotlex]
+			break;
+		case BL_ITEM:
+			map_clearflooritem(bl);
+			break;
+		case BL_SKILL:
+			skill_delunit((struct skill_unit *) bl);
+			break;
+	}
+
+	return 1;
 }
 
 /**
@@ -3504,7 +3541,7 @@ int cleanup_sub(struct block_list *bl, va_list ap)
  */
 static int cleanup_db_sub(DBKey key, DBData *data, va_list va)
 {
-    return cleanup_sub(db_data2ptr(data), va);
+	return cleanup_sub(db_data2ptr(data), va);
 }
 
 /*==========================================
@@ -3512,91 +3549,91 @@ static int cleanup_db_sub(DBKey key, DBData *data, va_list va)
  *------------------------------------------*/
 void do_final(void)
 {
-    int i, j;
-    struct map_session_data *sd;
-    struct s_mapiterator *iter;
-
-    ShowStatus("Terminating...\n");
-
-    //Ladies and babies first.
-    iter = mapit_getallusers();
-    for (sd = (TBL_PC *)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC *)mapit_next(iter))
-        map_quit(sd);
-    mapit_free(iter);
-
-    /* prepares npcs for a faster shutdown process */
-    do_clear_npc();
-
-    // remove all objects on maps
-    for (i = 0; i < map_num; i++) {
-        ShowStatus("Cleaning up maps [%d/%d]: %s..."CL_CLL"\r", i+1, map_num, map[i].name);
-        if (map[i].m >= 0)
-            map_foreachinmap(cleanup_sub, i, BL_ALL);
-    }
-    ShowStatus("Cleaned up %d maps."CL_CLL"\n", map_num);
-
-    id_db->foreach(id_db,cleanup_db_sub);
-    chrif_char_reset_offline();
-    chrif_flush_fifo();
-
-    do_final_atcommand();
-    do_final_battle();
-    do_final_chrif();
-    do_final_clif();
-    do_final_npc();
-    do_final_script();
-    do_final_instance();
-    do_final_itemdb();
-    do_final_storage();
-    do_final_guild();
-    do_final_party();
-    do_final_pc();
-    do_final_pet();
-    do_final_mob();
-    do_final_msg();
-    do_final_skill();
-    do_final_status();
-    do_final_unit();
-    do_final_battleground();
-    do_final_duel();
-    do_final_elemental();
-
-    map_db->destroy(map_db, map_db_final);
-
-    for (i=0; i<map_num; i++) {
-        if (map[i].cell) aFree(map[i].cell);
-        if (map[i].block) aFree(map[i].block);
-        if (map[i].block_mob) aFree(map[i].block_mob);
-        if (battle_config.dynamic_mobs) { //Dynamic mobs flag by [random]
-            if (map[i].mob_delete_timer != INVALID_TIMER)
-                delete_timer(map[i].mob_delete_timer, map_removemobs_timer);
-            for (j=0; j<MAX_MOB_LIST_PER_MAP; j++)
-                if (map[i].moblist[j]) aFree(map[i].moblist[j]);
-        }
-    }
-
-    mapindex_final();
-    if (enable_grf)
-        grfio_final();
-
-    id_db->destroy(id_db, NULL);
-    pc_db->destroy(pc_db, NULL);
-    mobid_db->destroy(mobid_db, NULL);
-    bossid_db->destroy(bossid_db, NULL);
-    nick_db->destroy(nick_db, nick_db_final);
-    charid_db->destroy(charid_db, NULL);
-    iwall_db->destroy(iwall_db, NULL);
-    regen_db->destroy(regen_db, NULL);
+	int i, j;
+	struct map_session_data* sd;
+	struct s_mapiterator* iter;
+
+	ShowStatus("Terminating...\n");
+
+	//Ladies and babies first.
+	iter = mapit_getallusers();
+	for( sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC*)mapit_next(iter) )
+		map_quit(sd);
+	mapit_free(iter);
+
+	/* prepares npcs for a faster shutdown process */
+	do_clear_npc();
+
+	// remove all objects on maps
+	for (i = 0; i < map_num; i++) {
+		ShowStatus("Cleaning up maps [%d/%d]: %s..."CL_CLL"\r", i+1, map_num, map[i].name);
+		if (map[i].m >= 0)
+			map_foreachinmap(cleanup_sub, i, BL_ALL);
+	}
+	ShowStatus("Cleaned up %d maps."CL_CLL"\n", map_num);
+
+	id_db->foreach(id_db,cleanup_db_sub);
+	chrif_char_reset_offline();
+	chrif_flush_fifo();
+
+	do_final_atcommand();
+	do_final_battle();
+	do_final_chrif();
+	do_final_clif();
+	do_final_npc();
+	do_final_script();
+	do_final_instance();
+	do_final_itemdb();
+	do_final_storage();
+	do_final_guild();
+	do_final_party();
+	do_final_pc();
+	do_final_pet();
+	do_final_mob();
+	do_final_msg();
+	do_final_skill();
+	do_final_status();
+	do_final_unit();
+	do_final_battleground();
+	do_final_duel();
+	do_final_elemental();
+
+	map_db->destroy(map_db, map_db_final);
+
+	for (i=0; i<map_num; i++) {
+		if(map[i].cell) aFree(map[i].cell);
+		if(map[i].block) aFree(map[i].block);
+		if(map[i].block_mob) aFree(map[i].block_mob);
+		if(battle_config.dynamic_mobs) { //Dynamic mobs flag by [random]
+			if(map[i].mob_delete_timer != INVALID_TIMER)
+				delete_timer(map[i].mob_delete_timer, map_removemobs_timer);
+			for (j=0; j<MAX_MOB_LIST_PER_MAP; j++)
+				if (map[i].moblist[j]) aFree(map[i].moblist[j]);
+		}
+	}
+
+	mapindex_final();
+	if(enable_grf)
+		grfio_final();
+
+	id_db->destroy(id_db, NULL);
+	pc_db->destroy(pc_db, NULL);
+	mobid_db->destroy(mobid_db, NULL);
+	bossid_db->destroy(bossid_db, NULL);
+	nick_db->destroy(nick_db, nick_db_final);
+	charid_db->destroy(charid_db, NULL);
+	iwall_db->destroy(iwall_db, NULL);
+	regen_db->destroy(regen_db, NULL);
 
     map_sql_close();
 
-    ShowStatus("Finished.\n");
+	ShowStatus("Finished.\n");
 }
 
-static int map_abort_sub(struct map_session_data *sd, va_list ap)
+static int map_abort_sub(struct map_session_data* sd, va_list ap)
 {
-    chrif_save(sd,1);
-    return 1;
+	chrif_save(sd,1);
+	return 1;
 }
 
 
@@ -3606,21 +3643,22 @@ static int map_abort_sub(struct map_session_data *sd, va_list ap)
 //------------------------------
 void do_abort(void)
 {
-    static int run = 0;
-    //Save all characters and then flush the inter-connection.
-    if (run) {
-        ShowFatalError("Server has crashed while trying to save characters. Character data can't be saved!\n");
-        return;
-    }
-    run = 1;
-    if (!chrif_isconnected()) {
-        if (pc_db->size(pc_db))
-            ShowFatalError("Server has crashed without a connection to the char-server, %u characters can't be saved!\n", pc_db->size(pc_db));
-        return;
-    }
-    ShowError("Server received crash signal! Attempting to save all online characters!\n");
-    map_foreachpc(map_abort_sub);
-    chrif_flush_fifo();
+	static int run = 0;
+	//Save all characters and then flush the inter-connection.
+	if (run) {
+		ShowFatalError("Server has crashed while trying to save characters. Character data can't be saved!\n");
+		return;
+	}
+	run = 1;
+	if (!chrif_isconnected())
+	{
+		if (pc_db->size(pc_db))
+			ShowFatalError("Server has crashed without a connection to the char-server, %u characters can't be saved!\n", pc_db->size(pc_db));
+		return;
+	}
+	ShowError("Server received crash signal! Attempting to save all online characters!\n");
+	map_foreachpc(map_abort_sub);
+	chrif_flush_fifo();
 }
 
 /*======================================================
@@ -3628,22 +3666,22 @@ void do_abort(void)
  *------------------------------------------------------*/
 static void map_helpscreen(bool do_exit)
 {
-    ShowInfo("Usage: %s [options]\n", SERVER_NAME);
-    ShowInfo("\n");
-    ShowInfo("Options:\n");
-    ShowInfo("  -?, -h [--help]\t\tDisplays this help screen.\n");
-    ShowInfo("  -v [--version]\t\tDisplays the server's version.\n");
-    ShowInfo("  --run-once\t\t\tCloses server after loading (testing).\n");
-    ShowInfo("  --map-config <file>\t\tAlternative map-server configuration.\n");
-    ShowInfo("  --battle-config <file>\tAlternative battle configuration.\n");
-    ShowInfo("  --atcommand-config <file>\tAlternative atcommand configuration.\n");
-    ShowInfo("  --script-config <file>\tAlternative script configuration.\n");
-    ShowInfo("  --msg-config <file>\t\tAlternative message configuration.\n");
-    ShowInfo("  --grf-path <file>\t\tAlternative GRF path configuration.\n");
-    ShowInfo("  --inter-config <file>\t\tAlternative inter-server configuration.\n");
-    ShowInfo("  --log-config <file>\t\tAlternative logging configuration.\n");
-    if (do_exit)
-        exit(EXIT_SUCCESS);
+	ShowInfo("Usage: %s [options]\n", SERVER_NAME);
+	ShowInfo("\n");
+	ShowInfo("Options:\n");
+	ShowInfo("  -?, -h [--help]\t\tDisplays this help screen.\n");
+	ShowInfo("  -v [--version]\t\tDisplays the server's version.\n");
+	ShowInfo("  --run-once\t\t\tCloses server after loading (testing).\n");
+	ShowInfo("  --map-config <file>\t\tAlternative map-server configuration.\n");
+	ShowInfo("  --battle-config <file>\tAlternative battle configuration.\n");
+	ShowInfo("  --atcommand-config <file>\tAlternative atcommand configuration.\n");
+	ShowInfo("  --script-config <file>\tAlternative script configuration.\n");
+	ShowInfo("  --msg-config <file>\t\tAlternative message configuration.\n");
+	ShowInfo("  --grf-path <file>\t\tAlternative GRF path configuration.\n");
+	ShowInfo("  --inter-config <file>\t\tAlternative inter-server configuration.\n");
+	ShowInfo("  --log-config <file>\t\tAlternative logging configuration.\n");
+	if( do_exit )
+		exit(EXIT_SUCCESS);
 }
 
 /*======================================================
@@ -3651,12 +3689,12 @@ static void map_helpscreen(bool do_exit)
  *------------------------------------------------------*/
 static void map_versionscreen(bool do_exit)
 {
-    ShowInfo(CL_WHITE"rAthena SVN version: %s" CL_RESET"\n", get_svn_revision());
-    ShowInfo(CL_GREEN"Website/Forum:"CL_RESET"\thttp://rathena.org/\n");
-    ShowInfo(CL_GREEN"IRC Channel:"CL_RESET"\tirc://irc.rathena.net/#rathena\n");
-    ShowInfo("Open "CL_WHITE"readme.txt"CL_RESET" for more information.\n");
-    if (do_exit)
-        exit(EXIT_SUCCESS);
+	ShowInfo(CL_WHITE"rAthena SVN version: %s" CL_RESET"\n", get_svn_revision());
+	ShowInfo(CL_GREEN"Website/Forum:"CL_RESET"\thttp://rathena.org/\n");
+	ShowInfo(CL_GREEN"IRC Channel:"CL_RESET"\tirc://irc.rathena.net/#rathena\n");
+	ShowInfo("Open "CL_WHITE"readme.html"CL_RESET" for more information.\n");
+	if( do_exit )
+		exit(EXIT_SUCCESS);
 }
 
 /*======================================================
@@ -3664,219 +3702,249 @@ static void map_versionscreen(bool do_exit)
  *------------------------------------------------------*/
 void set_server_type(void)
 {
-    SERVER_TYPE = ATHENA_SERVER_MAP;
+	SERVER_TYPE = ATHENA_SERVER_MAP;
 }
 
 
 /// Called when a terminate signal is received.
 void do_shutdown(void)
 {
-    if (runflag != MAPSERVER_ST_SHUTDOWN) {
-        runflag = MAPSERVER_ST_SHUTDOWN;
-        ShowStatus("Shutting down...\n");
-        {
-            struct map_session_data *sd;
-            struct s_mapiterator *iter = mapit_getallusers();
-            for (sd = (TBL_PC *)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC *)mapit_next(iter))
-                clif_GM_kick(NULL, sd);
-            mapit_free(iter);
-            flush_fifos();
-        }
-        chrif_check_shutdown();
-    }
+	if( runflag != MAPSERVER_ST_SHUTDOWN )
+	{
+		runflag = MAPSERVER_ST_SHUTDOWN;
+		ShowStatus("Shutting down...\n");
+		{
+			struct map_session_data* sd;
+			struct s_mapiterator* iter = mapit_getallusers();
+			for( sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC*)mapit_next(iter) )
+				clif_GM_kick(NULL, sd);
+			mapit_free(iter);
+			flush_fifos();
+		}
+		chrif_check_shutdown();
+	}
 }
 
-static bool map_arg_next_value(const char *option, int i, int argc)
+static bool map_arg_next_value(const char* option, int i, int argc)
 {
-    if (i >= argc-1) {
-        ShowWarning("Missing value for option '%s'.\n", option);
-        return false;
-    }
+	if( i >= argc-1 )
+	{
+		ShowWarning("Missing value for option '%s'.\n", option);
+		return false;
+	}
 
-    return true;
+	return true;
 }
 
 int do_init(int argc, char *argv[])
 {
-    int i;
+	int i;
 
 #ifdef GCOLLECT
-    GC_enable_incremental();
+	GC_enable_incremental();
 #endif
 
-    INTER_CONF_NAME="conf/inter_athena.conf";
-    LOG_CONF_NAME="conf/log_athena.conf";
-    MAP_CONF_NAME = "conf/map_athena.conf";
-    BATTLE_CONF_FILENAME = "conf/battle_athena.conf";
-    ATCOMMAND_CONF_FILENAME = "conf/atcommand_athena.conf";
-    SCRIPT_CONF_NAME = "conf/script_athena.conf";
-    MSG_CONF_NAME = "conf/msg_athena.conf";
-    GRF_PATH_FILENAME = "conf/grf-files.txt";
-
-    rnd_init();
-
-    for (i = 1; i < argc ; i++) {
-        const char *arg = argv[i];
-
-        if (arg[0] != '-' && (arg[0] != '/' || arg[1] == '-')) {
-            // -, -- and /
-            ShowError("Unknown option '%s'.\n", argv[i]);
-            exit(EXIT_FAILURE);
-        } else if ((++arg)[0] == '-') {
-            // long option
-            arg++;
-
-            if (strcmp(arg, "help") == 0) {
-                map_helpscreen(true);
-            } else if (strcmp(arg, "version") == 0) {
-                map_versionscreen(true);
-            } else if (strcmp(arg, "map-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    MAP_CONF_NAME = argv[++i];
-            } else if (strcmp(arg, "battle-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    BATTLE_CONF_FILENAME = argv[++i];
-            } else if (strcmp(arg, "atcommand-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    ATCOMMAND_CONF_FILENAME = argv[++i];
-            } else if (strcmp(arg, "script-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    SCRIPT_CONF_NAME = argv[++i];
-            } else if (strcmp(arg, "msg-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    MSG_CONF_NAME = argv[++i];
-            } else if (strcmp(arg, "grf-path-file") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    GRF_PATH_FILENAME = argv[++i];
-            } else if (strcmp(arg, "inter-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    INTER_CONF_NAME = argv[++i];
-            } else if (strcmp(arg, "log-config") == 0) {
-                if (map_arg_next_value(arg, i, argc))
-                    LOG_CONF_NAME = argv[++i];
-            } else if (strcmp(arg, "run-once") == 0) { // close the map-server as soon as its done.. for testing [Celest]
-                runflag = CORE_ST_STOP;
-            } else {
-                ShowError("Unknown option '%s'.\n", argv[i]);
-                exit(EXIT_FAILURE);
-            }
-        } else switch (arg[0]) {
-                    // short option
-                case '?':
-                case 'h':
-                    map_helpscreen(true);
-                    break;
-                case 'v':
-                    map_versionscreen(true);
-                    break;
-                default:
-                    ShowError("Unknown option '%s'.\n", argv[i]);
-                    exit(EXIT_FAILURE);
-            }
-    }
-
-    map_config_read(MAP_CONF_NAME);
-    /* only temporary until sirius's datapack patch is complete  */
-
-    // loads npcs
-    map_reloadnpc(false);
-
-    chrif_checkdefaultlogin();
-
-    if (!map_ip_set || !char_ip_set) {
-        char ip_str[16];
-        ip2str(addr_[0], ip_str);
-
-        ShowWarning("Not all IP addresses in map_athena.conf configured, autodetecting...\n");
-
-        if (naddr_ == 0)
-            ShowError("Unable to determine your IP address...\n");
-        else if (naddr_ > 1)
-            ShowNotice("Multiple interfaces detected...\n");
-
-        ShowInfo("Defaulting to %s as our IP address\n", ip_str);
-
-        if (!map_ip_set)
-            clif_setip(ip_str);
-        if (!char_ip_set)
-            chrif_setip(ip_str);
-    }
-
-    battle_config_read(BATTLE_CONF_FILENAME);
-    msg_config_read(MSG_CONF_NAME);
-    script_config_read(SCRIPT_CONF_NAME);
-    inter_config_read(INTER_CONF_NAME);
-    log_config_read(LOG_CONF_NAME);
-
-    id_db = idb_alloc(DB_OPT_BASE);
-    pc_db = idb_alloc(DB_OPT_BASE); //Added for reliable map_id2sd() use. [Skotlex]
-    mobid_db = idb_alloc(DB_OPT_BASE);  //Added to lower the load of the lazy mob ai. [Skotlex]
-    bossid_db = idb_alloc(DB_OPT_BASE); // Used for Convex Mirror quick MVP search
-    map_db = uidb_alloc(DB_OPT_BASE);
-    nick_db = idb_alloc(DB_OPT_BASE);
-    charid_db = idb_alloc(DB_OPT_BASE);
-    regen_db = idb_alloc(DB_OPT_BASE); // efficient status_natural_heal processing
-
-    iwall_db = strdb_alloc(DB_OPT_RELEASE_DATA,2*NAME_LENGTH+2+1); // [Zephyrus] Invisible Walls
-
-    map_sql_init();
-    if (log_config.sql_logs)
-        log_sql_init();
-
-    mapindex_init();
-    if (enable_grf)
-        grfio_init(GRF_PATH_FILENAME);
-
-    map_readallmaps();
-
-    add_timer_func_list(map_freeblock_timer, "map_freeblock_timer");
-    add_timer_func_list(map_clearflooritem_timer, "map_clearflooritem_timer");
-    add_timer_func_list(map_removemobs_timer, "map_removemobs_timer");
-    add_timer_interval(gettick()+1000, map_freeblock_timer, 0, 0, 60*1000);
-
-    do_init_atcommand();
-    do_init_battle();
-    do_init_instance();
-    do_init_chrif();
-    do_init_clif();
-    do_init_script();
-    do_init_itemdb();
-    do_init_skill();
-    do_init_mob();
-    do_init_pc();
-    do_init_status();
-    do_init_party();
-    do_init_guild();
-    do_init_storage();
-    do_init_pet();
-    do_init_merc();
-    do_init_mercenary();
-    do_init_elemental();
-    do_init_quest();
-    do_init_npc();
-    do_init_unit();
-    do_init_battleground();
-    do_init_duel();
-
-    npc_event_do_oninit();  // Init npcs (OnInit)
-
-    if (console) {
-        //##TODO invoke a CONSOLE_START plugin event
-    }
-
-    if (battle_config.pk_mode)
-        ShowNotice("Server is running on '"CL_WHITE"PK Mode"CL_RESET"'.\n");
-
-    ShowStatus("Server is '"CL_GREEN"ready"CL_RESET"' and listening on port '"CL_WHITE"%d"CL_RESET"'.\n\n", map_port);
-
-    if (runflag != CORE_ST_STOP) {
-        shutdown_callback = do_shutdown;
-        runflag = MAPSERVER_ST_RUNNING;
-    }
+	INTER_CONF_NAME="conf/inter_athena.conf";
+	LOG_CONF_NAME="conf/log_athena.conf";
+	MAP_CONF_NAME = "conf/map_athena.conf";
+	BATTLE_CONF_FILENAME = "conf/battle_athena.conf";
+	ATCOMMAND_CONF_FILENAME = "conf/atcommand_athena.conf";
+	SCRIPT_CONF_NAME = "conf/script_athena.conf";
+	MSG_CONF_NAME = "conf/msg_athena.conf";
+	GRF_PATH_FILENAME = "conf/grf-files.txt";
+
+	rnd_init();
+
+	for( i = 1; i < argc ; i++ )
+	{
+		const char* arg = argv[i];
+
+		if( arg[0] != '-' && ( arg[0] != '/' || arg[1] == '-' ) )
+		{// -, -- and /
+			ShowError("Unknown option '%s'.\n", argv[i]);
+			exit(EXIT_FAILURE);
+		}
+		else if( (++arg)[0] == '-' )
+		{// long option
+			arg++;
+
+			if( strcmp(arg, "help") == 0 )
+			{
+				map_helpscreen(true);
+			}
+			else if( strcmp(arg, "version") == 0 )
+			{
+				map_versionscreen(true);
+			}
+			else if( strcmp(arg, "map-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					MAP_CONF_NAME = argv[++i];
+			}
+			else if( strcmp(arg, "battle-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					BATTLE_CONF_FILENAME = argv[++i];
+			}
+			else if( strcmp(arg, "atcommand-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					ATCOMMAND_CONF_FILENAME = argv[++i];
+			}
+			else if( strcmp(arg, "script-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					SCRIPT_CONF_NAME = argv[++i];
+			}
+			else if( strcmp(arg, "msg-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					MSG_CONF_NAME = argv[++i];
+			}
+			else if( strcmp(arg, "grf-path-file") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					GRF_PATH_FILENAME = argv[++i];
+			}
+			else if( strcmp(arg, "inter-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					INTER_CONF_NAME = argv[++i];
+			}
+			else if( strcmp(arg, "log-config") == 0 )
+			{
+				if( map_arg_next_value(arg, i, argc) )
+					LOG_CONF_NAME = argv[++i];
+			}
+			else if( strcmp(arg, "run-once") == 0 ) // close the map-server as soon as its done.. for testing [Celest]
+			{
+				runflag = CORE_ST_STOP;
+			}
+			else
+			{
+				ShowError("Unknown option '%s'.\n", argv[i]);
+				exit(EXIT_FAILURE);
+			}
+		}
+		else switch( arg[0] )
+		{// short option
+			case '?':
+			case 'h':
+				map_helpscreen(true);
+				break;
+			case 'v':
+				map_versionscreen(true);
+				break;
+			default:
+				ShowError("Unknown option '%s'.\n", argv[i]);
+				exit(EXIT_FAILURE);
+		}
+	}
+
+	map_config_read(MAP_CONF_NAME);
+	/* only temporary until sirius's datapack patch is complete  */
+
+	// loads npcs
+	map_reloadnpc(false);
+
+	chrif_checkdefaultlogin();
+
+	if (!map_ip_set || !char_ip_set) {
+		char ip_str[16];
+		ip2str(addr_[0], ip_str);
+
+		ShowWarning("Not all IP addresses in map_athena.conf configured, autodetecting...\n");
+
+		if (naddr_ == 0)
+			ShowError("Unable to determine your IP address...\n");
+		else if (naddr_ > 1)
+			ShowNotice("Multiple interfaces detected...\n");
+
+		ShowInfo("Defaulting to %s as our IP address\n", ip_str);
+
+		if (!map_ip_set)
+			clif_setip(ip_str);
+		if (!char_ip_set)
+			chrif_setip(ip_str);
+	}
+
+	battle_config_read(BATTLE_CONF_FILENAME);
+	msg_config_read(MSG_CONF_NAME);
+	script_config_read(SCRIPT_CONF_NAME);
+	inter_config_read(INTER_CONF_NAME);
+	log_config_read(LOG_CONF_NAME);
+
+	id_db = idb_alloc(DB_OPT_BASE);
+	pc_db = idb_alloc(DB_OPT_BASE);	//Added for reliable map_id2sd() use. [Skotlex]
+	mobid_db = idb_alloc(DB_OPT_BASE);	//Added to lower the load of the lazy mob ai. [Skotlex]
+	bossid_db = idb_alloc(DB_OPT_BASE); // Used for Convex Mirror quick MVP search
+	map_db = uidb_alloc(DB_OPT_BASE);
+	nick_db = idb_alloc(DB_OPT_BASE);
+	charid_db = idb_alloc(DB_OPT_BASE);
+	regen_db = idb_alloc(DB_OPT_BASE); // efficient status_natural_heal processing
+
+	iwall_db = strdb_alloc(DB_OPT_RELEASE_DATA,2*NAME_LENGTH+2+1); // [Zephyrus] Invisible Walls
+
+	map_sql_init();
+	if (log_config.sql_logs)
+		log_sql_init();
+
+	mapindex_init();
+	if(enable_grf)
+		grfio_init(GRF_PATH_FILENAME);
+
+	map_readallmaps();
+
+	add_timer_func_list(map_freeblock_timer, "map_freeblock_timer");
+	add_timer_func_list(map_clearflooritem_timer, "map_clearflooritem_timer");
+	add_timer_func_list(map_removemobs_timer, "map_removemobs_timer");
+	add_timer_interval(gettick()+1000, map_freeblock_timer, 0, 0, 60*1000);
+
+	do_init_atcommand();
+	do_init_battle();
+	do_init_instance();
+	do_init_chrif();
+	do_init_clif();
+	do_init_script();
+	do_init_itemdb();
+	do_init_skill();
+	do_init_mob();
+	do_init_pc();
+	do_init_status();
+	do_init_party();
+	do_init_guild();
+	do_init_storage();
+	do_init_pet();
+	do_init_merc();
+	do_init_mercenary();
+	do_init_elemental();
+	do_init_quest();
+	do_init_npc();
+	do_init_unit();
+	do_init_battleground();
+	do_init_duel();
+
+	npc_event_do_oninit();	// Init npcs (OnInit)
+
+	if( console )
+	{
+		//##TODO invoke a CONSOLE_START plugin event
+	}
+
+	if (battle_config.pk_mode)
+		ShowNotice("Server is running on '"CL_WHITE"PK Mode"CL_RESET"'.\n");
+
+	ShowStatus("Server is '"CL_GREEN"ready"CL_RESET"' and listening on port '"CL_WHITE"%d"CL_RESET"'.\n\n", map_port);
+
+	if( runflag != CORE_ST_STOP )
+	{
+		shutdown_callback = do_shutdown;
+		runflag = MAPSERVER_ST_RUNNING;
+	}
 #if defined(BUILDBOT)
-    if (buildbotflag)
-        exit(EXIT_FAILURE);
+	if( buildbotflag )
+		exit(EXIT_FAILURE);
 #endif
 
-    return 0;
+	return 0;
 }