summaryrefslogtreecommitdiff
path: root/src/map/map.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/map/map.c')
-rw-r--r--src/map/map.c5622
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;
}