Mirroristas/rathena
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixes damage skills which ignored walls. (#1453)

Browse Source 
* Fixes damage skills which ignored walls.
* The following functions were adjusted for the battle config skill_wall_check.
* Changed map_foreachinrange behavior:
- map_foreachinallrange is now the old map_foreachinrange
- map_foreachinrange does not check for a wall
- map_foreachinshootrange always checks for a wall
* Changed map_foreachinarea behavior:
- map_foreachinallarea is now the old map_foreachinarea
- map_foreachinarea does not check for a wall
- map_foreachinshootarea always checks for a wall
This commit is contained in:
Jeybla 2017-06-15 01:28:59 +02:00 committed by Aleos
parent 5f61ee6ecd
commit 05a778d6a3
14 changed files with 271 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/map/atcommand.c
View File

@ -5330,7 +5330,7 @@ ACMD_FUNC(killable)
clif_displaymessage(fd, msg_txt(sd,242));
else {
clif_displaymessage(fd, msg_txt(sd,288));
map_foreachinrange(atcommand_stopattack,&sd->bl, AREA_SIZE, BL_CHAR, sd->bl.id);
map_foreachinallrange(atcommand_stopattack,&sd->bl, AREA_SIZE, BL_CHAR, sd->bl.id);
}
return 0;
}
@ -5391,9 +5391,9 @@ ACMD_FUNC(npcmove)
x = cap_value(x, 0, map[m].xs-1);
y = cap_value(y, 0, map[m].ys-1);
map_foreachinrange(clif_outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_foreachinallrange(clif_outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_moveblock(&nd->bl, x, y, gettick());
map_foreachinrange(clif_insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_foreachinallrange(clif_insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
clif_displaymessage(fd, msg_txt(sd,1155)); // NPC moved.
return 0;
@ -6580,13 +6580,13 @@ ACMD_FUNC(cleanarea)
short x0 = 0, y0 = 0, x1 = 0, y1 = 0;
if (!message || !*message || sscanf(message, "%6hd %6hd %6hd %6hd", &x0, &y0, &x1, &y1) < 1) {
map_foreachinarea(atcommand_cleanfloor_sub, sd->bl.m, sd->bl.x - (AREA_SIZE * 2), sd->bl.y - (AREA_SIZE * 2), sd->bl.x + (AREA_SIZE * 2), sd->bl.y + (AREA_SIZE * 2), BL_ITEM);
map_foreachinallarea(atcommand_cleanfloor_sub, sd->bl.m, sd->bl.x - (AREA_SIZE * 2), sd->bl.y - (AREA_SIZE * 2), sd->bl.x + (AREA_SIZE * 2), sd->bl.y + (AREA_SIZE * 2), BL_ITEM);
}
else if (sscanf(message, "%6hd %6hd %6hd %6hd", &x0, &y0, &x1, &y1) == 1) {
map_foreachinarea(atcommand_cleanfloor_sub, sd->bl.m, sd->bl.x - x0, sd->bl.y - x0, sd->bl.x + x0, sd->bl.y + x0, BL_ITEM);
map_foreachinallarea(atcommand_cleanfloor_sub, sd->bl.m, sd->bl.x - x0, sd->bl.y - x0, sd->bl.x + x0, sd->bl.y + x0, BL_ITEM);
}
else if (sscanf(message, "%6hd %6hd %6hd %6hd", &x0, &y0, &x1, &y1) == 4) {
map_foreachinarea(atcommand_cleanfloor_sub, sd->bl.m, x0, y0, x1, y1, BL_ITEM);
map_foreachinallarea(atcommand_cleanfloor_sub, sd->bl.m, x0, y0, x1, y1, BL_ITEM);
}
clif_displaymessage(fd, msg_txt(sd,1221)); // All dropped items have been cleaned up.
@ -7874,7 +7874,7 @@ ACMD_FUNC(mutearea)
time = atoi(message);
map_foreachinarea(atcommand_mutearea_sub,sd->bl.m,
map_foreachinallarea(atcommand_mutearea_sub,sd->bl.m,
sd->bl.x-AREA_SIZE, sd->bl.y-AREA_SIZE,
sd->bl.x+AREA_SIZE, sd->bl.y+AREA_SIZE, BL_PC, sd->bl.id, time);

6
src/map/battle.c
View File

@ -96,7 +96,7 @@ struct block_list* battle_gettargeted(struct block_list *target)
nullpo_retr(NULL, target);
memset(bl_list, 0, sizeof(bl_list));
map_foreachinrange(battle_gettargeted_sub, target, AREA_SIZE, BL_CHAR, bl_list, &c, target->id);
map_foreachinallrange(battle_gettargeted_sub, target, AREA_SIZE, BL_CHAR, bl_list, &c, target->id);
if ( c == 0 )
return NULL;
if( c > 24 )
@ -172,7 +172,7 @@ struct block_list* battle_getenemy(struct block_list *target, int type, int rang
int c = 0;
memset(bl_list, 0, sizeof(bl_list));
map_foreachinrange(battle_getenemy_sub, target, range, type, bl_list, &c, target);
map_foreachinallrange(battle_getenemy_sub, target, range, type, bl_list, &c, target);
if ( c == 0 )
return NULL;
@ -232,7 +232,7 @@ struct block_list* battle_getenemyarea(struct block_list *src, int x, int y, int
int c = 0;
memset(bl_list, 0, sizeof(bl_list));
map_foreachinarea(battle_getenemyarea_sub, src->m, x - range, y - range, x + range, y + range, type, bl_list, &c, src, ignore_id);
map_foreachinallarea(battle_getenemyarea_sub, src->m, x - range, y - range, x + range, y + range, type, bl_list, &c, src, ignore_id);
if( c == 0 )
return NULL;

14
src/map/clif.c
View File

@ -293,7 +293,7 @@ static bool clif_session_isValid(struct map_session_data *sd) {
/*==========================================
* sub process of clif_send
* Called from a map_foreachinarea (grabs all players in specific area and subjects them to this function)
* Called from a map_foreachinallarea (grabs all players in specific area and subjects them to this function)
* In order to send area-wise packets, such as:
* - AREA : everyone nearby your area
* - AREA_WOSC (AREA WITHOUT SAME CHAT) : Not run for people in the same chat as yours
@ -427,11 +427,11 @@ int clif_send(const uint8* buf, int len, struct block_list* bl, enum send_target
clif_send (buf, len, bl, SELF);
case AREA_WOC:
case AREA_WOS:
map_foreachinarea(clif_send_sub, bl->m, bl->x-AREA_SIZE, bl->y-AREA_SIZE, bl->x+AREA_SIZE, bl->y+AREA_SIZE,
map_foreachinallarea(clif_send_sub, bl->m, bl->x-AREA_SIZE, bl->y-AREA_SIZE, bl->x+AREA_SIZE, bl->y+AREA_SIZE,
BL_PC, buf, len, bl, type);
break;
case AREA_CHAT_WOC:
map_foreachinarea(clif_send_sub, bl->m, bl->x-(AREA_SIZE-5), bl->y-(AREA_SIZE-5),
map_foreachinallarea(clif_send_sub, bl->m, bl->x-(AREA_SIZE-5), bl->y-(AREA_SIZE-5),
bl->x+(AREA_SIZE-5), bl->y+(AREA_SIZE-5), BL_PC, buf, len, bl, AREA_WOC);
break;
@ -3160,7 +3160,7 @@ static int clif_hpmeter_sub(struct block_list *bl, va_list ap)
static int clif_hpmeter(struct map_session_data *sd)
{
nullpo_ret(sd);
map_foreachinarea(clif_hpmeter_sub, sd->bl.m, sd->bl.x-AREA_SIZE, sd->bl.y-AREA_SIZE, sd->bl.x+AREA_SIZE, sd->bl.y+AREA_SIZE, BL_PC, sd);
map_foreachinallarea(clif_hpmeter_sub, sd->bl.m, sd->bl.x-AREA_SIZE, sd->bl.y-AREA_SIZE, sd->bl.x+AREA_SIZE, sd->bl.y+AREA_SIZE, BL_PC, sd);
return 0;
}
@ -9372,7 +9372,7 @@ void clif_refresh(struct map_session_data *sd)
}
if( sd->ed )
clif_elemental_info(sd);
map_foreachinrange(clif_getareachar,&sd->bl,AREA_SIZE,BL_ALL,sd);
map_foreachinallrange(clif_getareachar,&sd->bl,AREA_SIZE,BL_ALL,sd);
clif_weather_check(sd);
if( sd->chatID )
chat_leavechat(sd,0);
@ -10284,7 +10284,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd)
// info about nearby objects
// must use foreachinarea (CIRCULAR_AREA interferes with foreachinrange)
map_foreachinarea(clif_getareachar, sd->bl.m, sd->bl.x-AREA_SIZE, sd->bl.y-AREA_SIZE, sd->bl.x+AREA_SIZE, sd->bl.y+AREA_SIZE, BL_ALL, sd);
map_foreachinallarea(clif_getareachar, sd->bl.m, sd->bl.x-AREA_SIZE, sd->bl.y-AREA_SIZE, sd->bl.x+AREA_SIZE, sd->bl.y+AREA_SIZE, BL_ALL, sd);
// pet
if( sd->pd ) {
@ -10814,7 +10814,7 @@ void clif_parse_GlobalMessage(int fd, struct map_session_data* sd)
#ifdef PCRE_SUPPORT
// trigger listening npcs
map_foreachinrange(npc_chat_sub, &sd->bl, AREA_SIZE, BL_NPC, output, strlen(output), &sd->bl);
map_foreachinallrange(npc_chat_sub, &sd->bl, AREA_SIZE, BL_NPC, output, strlen(output), &sd->bl);
#endif
// Chat logging type 'O' / Global Chat

2
src/map/elemental.c
View File

@ -708,7 +708,7 @@ static int elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_
target = map_id2bl(ed->ud.target);
if( !target )
map_foreachinrange(elemental_ai_sub_timer_activesearch, &ed->bl, view_range, BL_CHAR, ed, &target, status_get_mode(&ed->bl));
map_foreachinallrange(elemental_ai_sub_timer_activesearch, &ed->bl, view_range, BL_CHAR, ed, &target, status_get_mode(&ed->bl));
if( !target ) { //No targets available.
elemental_unlocktarget(ed);

6
src/map/instance.c
View File

@ -345,11 +345,11 @@ void instance_addnpc(struct instance_data *im)
// First add the NPCs
for(i = 0; i < im->cnt_map; i++)
map_foreachinarea(instance_addnpc_sub, im->map[i]->src_m, 0, 0, map[im->map[i]->src_m].xs, map[im->map[i]->src_m].ys, BL_NPC, im->map[i]->m);
map_foreachinallarea(instance_addnpc_sub, im->map[i]->src_m, 0, 0, map[im->map[i]->src_m].xs, map[im->map[i]->src_m].ys, BL_NPC, im->map[i]->m);
// Now run their OnInstanceInit
for(i = 0; i < im->cnt_map; i++)
map_foreachinarea(instance_npcinit, im->map[i]->m, 0, 0, map[im->map[i]->m].xs, map[im->map[i]->m].ys, BL_NPC, im->map[i]->m);
map_foreachinallarea(instance_npcinit, im->map[i]->m, 0, 0, map[im->map[i]->m].xs, map[im->map[i]->m].ys, BL_NPC, im->map[i]->m);
}
@ -654,7 +654,7 @@ int instance_destroy(unsigned short instance_id)
// Run OnInstanceDestroy on all NPCs in the instance
for(i = 0; i < im->cnt_map; i++){
map_foreachinarea(instance_npcdestroy, im->map[i]->m, 0, 0, map[im->map[i]->m].xs, map[im->map[i]->m].ys, BL_NPC, im->map[i]->m);
map_foreachinallarea(instance_npcdestroy, im->map[i]->m, 0, 0, map[im->map[i]->m].xs, map[im->map[i]->m].ys, BL_NPC, im->map[i]->m);
}
for(i = 0; i < im->cnt_map; i++) {

246
src/map/map.c
View File

@ -566,79 +566,14 @@ struct skill_unit* map_find_skill_unit_oncell(struct block_list* target,int16 x,
/*==========================================
* Adapted from foreachinarea for an easier invocation. [Skotlex]
*------------------------------------------*/
int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...)
int map_foreachinrangeV(int (*func)(struct block_list*,va_list),struct block_list* center, int16 range, int type, va_list ap, bool wall_check)
{
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 = i16max(center->x - range, 0);
y0 = i16max(center->y - range, 0);
x1 = i16min(center->x + range, map[ m ].xs - 1);
y1 = i16min(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)
#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
#ifdef CIRCULAR_AREA
&& 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_foreachinrange: 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 wasn't 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]
}
/*==========================================
* 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, int16 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;
va_list ap_copy;
m = center->m;
if( m < 0 )
@ -649,7 +584,7 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
x1 = i16min(center->x + range, map[m].xs - 1);
y1 = i16min(center->y + range, map[m].ys - 1);
if ( type&~BL_MOB )
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 ) {
@ -658,13 +593,15 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
#ifdef CIRCULAR_AREA
&& check_distance_bl(center, bl, range)
#endif
&& path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
&& ( !wall_check || 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 )
}
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 ) {
@ -672,23 +609,25 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
#ifdef CIRCULAR_AREA
&& check_distance_bl(center, bl, range)
#endif
&& path_search_long(NULL, center->m, center->x, center->y, bl->x, bl->y, CELL_CHKWALL)
&& ( !wall_check || 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");
map_freeblock_lock();
for( i = blockcount; i < bl_list_count; i++ )
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 wasn't queued for deletion.
va_start(ap, type);
returnCount += func(bl_list[ i ], ap);
va_end(ap);
va_copy(ap_copy, ap);
returnCount += func(bl_list[i], ap_copy);
va_end(ap_copy);
}
}
map_freeblock_unlock();
@ -697,65 +636,43 @@ int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block
return returnCount; //[Skotlex]
}
int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...)
{
int returnCount = 0;
va_list ap;
va_start(ap,type);
returnCount = map_foreachinrangeV(func,center,range,type,ap,battle_config.skill_wall_check>0);
va_end(ap);
return returnCount;
}
int map_foreachinallrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...)
{
int returnCount = 0;
va_list ap;
va_start(ap,type);
returnCount = map_foreachinrangeV(func,center,range,type,ap,false);
va_end(ap);
return returnCount;
}
/*==========================================
* range = map m (x0,y0)-(x1,y1)
* Apply *func with ... arguments for the range.
* @type = BL_PC/BL_MOB etc..
* Same as foreachinrange, but there must be a shoot-able range between center and target to be counted in. [Skotlex]
*------------------------------------------*/
int map_foreachinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
int map_foreachinshootrange(int (*func)(struct block_list*,va_list),struct block_list* center, int16 range, 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;
int returnCount = 0;
va_list ap;
if ( m < 0 || m >= map_num)
return 0;
if ( x1 < x0 )
swap(x0, x1);
if ( y1 < y0 )
swap(y0, y1);
x0 = i16max(x0, 0);
y0 = i16max(y0, 0);
x1 = i16min(x1, map[ m ].xs - 1);
y1 = i16min(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 wasn't queued for deletion.
va_start(ap,type);
returnCount += func(bl_list[ i ], ap);
returnCount = map_foreachinrangeV(func,center,range,type,ap,true);
va_end(ap);
return returnCount;
}
map_freeblock_unlock();
bl_list_count = blockcount;
return returnCount; //[Skotlex]
}
/*========================================== [Playtester]
* Same as foreachinarea, but there must be a shoot-able range between area center and target.
* range = map m (x0,y0)-(x1,y1)
* Apply *func with ... arguments for the range.
* @param m: ID of map
* @param x0: West end of area
* @param y0: South end of area
@ -763,13 +680,13 @@ int map_foreachinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0
* @param y1: North end of area
* @param type: Type of bl to search for
*------------------------------------------*/
int map_foreachinshootarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
int map_foreachinareaV(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap, bool wall_check)
{
int bx, by, cx, cy;
int returnCount = 0; //total sum of returned values of func()
struct block_list *bl;
int blockcount = bl_list_count, i;
va_list ap;
va_list ap_copy;
if (m < 0 || m >= map_num)
return 0;
@ -784,37 +701,49 @@ int map_foreachinshootarea(int(*func)(struct block_list*, va_list), int16 m, int
x1 = i16min(x1, map[m].xs - 1);
y1 = i16min(y1, map[m].ys - 1);
if( wall_check ) {
cx = x0 + (x1 - x0) / 2;
cy = y0 + (y1 - y0) / 2;
}
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
&& path_search_long(NULL, m, cx, cy, bl->x, bl->y, CELL_CHKWALL)
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
&& ( !wall_check || path_search_long(NULL, m, cx, cy, 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( 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, m, cx, cy, bl->x, bl->y, CELL_CHKWALL)
&& ( !wall_check || path_search_long(NULL, m, cx, cy, 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_foreachinshootarea: block count too many!\n");
ShowWarning("map_foreachinarea: block count too many!\n");
map_freeblock_lock();
for (i = blockcount; i < bl_list_count; i++)
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 wasn't queued for deletion.
va_start(ap, type);
returnCount += func(bl_list[i], ap);
va_end(ap);
va_copy(ap_copy, ap);
returnCount += func(bl_list[i], ap_copy);
va_end(ap_copy);
}
}
map_freeblock_unlock();
@ -823,6 +752,35 @@ int map_foreachinshootarea(int(*func)(struct block_list*, va_list), int16 m, int
return returnCount;
}
int map_foreachinallarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
{
int returnCount = 0;
va_list ap;
va_start(ap,type);
returnCount = map_foreachinareaV(func,m,x0,y0,x1,y1,type,ap,false);
va_end(ap);
return returnCount;
}
int map_foreachinshootarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
{
int returnCount = 0;
va_list ap;
va_start(ap,type);
returnCount = map_foreachinareaV(func,m,x0,y0,x1,y1,type,ap,true);
va_end(ap);
return returnCount;
}
int map_foreachinarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...)
{
int returnCount = 0;
va_list ap;
va_start(ap,type);
returnCount = map_foreachinareaV(func,m,x0,y0,x1,y1,type,ap,battle_config.skill_wall_check>0);
va_end(ap);
return returnCount;
}
/*==========================================
* Adapted from forcountinarea for an easier invocation. [pakpil]
*------------------------------------------*/
@ -924,7 +882,7 @@ int map_forcountinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x
bl_list[ bl_list_count++ ] = bl;
if( bl_list_count >= BL_LIST_MAX )
ShowWarning("map_foreachinarea: block count too many!\n");
ShowWarning("map_forcountinarea: block count too many!\n");
map_freeblock_lock();
@ -1663,7 +1621,7 @@ int map_search_freecell(struct block_list *src, int16 m, int16 *x,int16 *y, int1
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,
map_foreachinallarea(map_count_sub, m,
*x-AREA_SIZE, *y-AREA_SIZE,
*x+AREA_SIZE, *y+AREA_SIZE, BL_PC)
)

2
src/map/map.h
View File

@ -797,8 +797,10 @@ int map_addblock(struct block_list* bl);
int map_delblock(struct block_list* bl);
int map_moveblock(struct block_list *, int, int, unsigned int);
int map_foreachinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...);
int map_foreachinallrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...);
int map_foreachinshootrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int type, ...);
int map_foreachinarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...);
int map_foreachinallarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...);
int map_foreachinshootarea(int(*func)(struct block_list*, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, ...);
int map_forcountinrange(int (*func)(struct block_list*,va_list), struct block_list* center, int16 range, int count, int type, ...);
int map_forcountinarea(int (*func)(struct block_list*,va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, ...);

18
src/map/mob.c
View File

@ -1050,7 +1050,7 @@ int mob_spawn (struct mob_data *md)
return 1;
}
}
else if( battle_config.no_spawn_on_player > 99 && map_foreachinrange(mob_count_sub, &md->bl, AREA_SIZE, BL_PC) )
else if( battle_config.no_spawn_on_player > 99 && map_foreachinallrange(mob_count_sub, &md->bl, AREA_SIZE, BL_PC) )
{ // retry again later (players on sight)
if( md->spawn_timer != INVALID_TIMER )
delete_timer(md->spawn_timer, mob_delayspawn);
@ -1584,7 +1584,7 @@ int mob_warpchase(struct mob_data *md, struct block_list *target)
return 1; //Already walking to a warp.
//Search for warps within mob's viewing range.
map_foreachinrange (mob_warpchase_sub, &md->bl,
map_foreachinallrange(mob_warpchase_sub, &md->bl,
md->db->range2, BL_NPC, target, &warp, &distance);
if (warp && unit_walktobl(&md->bl, &warp->bl, 1, 1))
@ -1734,14 +1734,14 @@ static bool mob_ai_sub_hard(struct mob_data *md, unsigned int tick)
if ((!tbl && mode&MD_AGGRESSIVE) || md->state.skillstate == MSS_FOLLOW)
{
map_foreachinrange (mob_ai_sub_hard_activesearch, &md->bl, view_range, DEFAULT_ENEMY_TYPE(md), md, &tbl, mode);
map_foreachinallrange (mob_ai_sub_hard_activesearch, &md->bl, view_range, DEFAULT_ENEMY_TYPE(md), md, &tbl, mode);
}
else
if (mode&MD_CHANGECHASE && (md->state.skillstate == MSS_RUSH || md->state.skillstate == MSS_FOLLOW))
{
int search_size;
search_size = view_range<md->status.rhw.range ? view_range:md->status.rhw.range;
map_foreachinrange (mob_ai_sub_hard_changechase, &md->bl, search_size, DEFAULT_ENEMY_TYPE(md), md, &tbl);
map_foreachinallrange (mob_ai_sub_hard_changechase, &md->bl, search_size, DEFAULT_ENEMY_TYPE(md), md, &tbl);
}
if (!tbl) { //No targets available.
@ -1749,7 +1749,7 @@ static bool mob_ai_sub_hard(struct mob_data *md, unsigned int tick)
if( md->bg_id && mode&MD_CANATTACK ) {
if( md->ud.walktimer != INVALID_TIMER )
return true;/* we are already moving */
map_foreachinrange (mob_ai_sub_hard_bg_ally, &md->bl, view_range, BL_PC, md, &tbl, mode);
map_foreachinallrange (mob_ai_sub_hard_bg_ally, &md->bl, view_range, BL_PC, md, &tbl, mode);
if( tbl ) {
if( distance_blxy(&md->bl, tbl->x, tbl->y) <= 3 || unit_walktobl(&md->bl, tbl, 1, 1) )
return true;/* we're moving or close enough don't unlock the target. */
@ -1906,7 +1906,7 @@ static int mob_ai_sub_foreachclient(struct map_session_data *sd,va_list ap)
{
unsigned int tick;
tick=va_arg(ap,unsigned int);
map_foreachinrange(mob_ai_sub_hard_timer,&sd->bl, AREA_SIZE+ACTIVE_AI_RANGE, BL_MOB, sd->status.char_id, tick);
map_foreachinallrange(mob_ai_sub_hard_timer,&sd->bl, AREA_SIZE+ACTIVE_AI_RANGE, BL_MOB, sd->status.char_id, tick);
return 0;
}
@ -2901,7 +2901,7 @@ int mob_dead(struct mob_data *md, struct block_list *src, int type)
}
if (sd->status.party_id)
map_foreachinrange(quest_update_objective_sub, &md->bl, AREA_SIZE, BL_PC, sd->status.party_id, md->mob_id);
map_foreachinallrange(quest_update_objective_sub, &md->bl, AREA_SIZE, BL_PC, sd->status.party_id, md->mob_id);
else if (sd->avail_quests)
quest_update_objective(sd, md->mob_id);
@ -3338,7 +3338,7 @@ static struct block_list *mob_getfriendhprate(struct mob_data *md,int min_rate,i
if (md->special_state.ai) //Summoned creatures. [Skotlex]
type = BL_PC;
map_foreachinrange(mob_getfriendhprate_sub, &md->bl, 8, type,md,min_rate,max_rate,&fr);
map_foreachinallrange(mob_getfriendhprate_sub, &md->bl, 8, type,md,min_rate,max_rate,&fr);
return fr;
}
/*==========================================
@ -3395,7 +3395,7 @@ struct mob_data *mob_getfriendstatus(struct mob_data *md,int cond1,int cond2)
struct mob_data* fr = NULL;
nullpo_ret(md);
map_foreachinrange(mob_getfriendstatus_sub, &md->bl, 8,BL_MOB, md,cond1,cond2,&fr);
map_foreachinallrange(mob_getfriendstatus_sub, &md->bl, 8,BL_MOB, md,cond1,cond2,&fr);
return fr;
}

10
src/map/npc.c
View File

@ -148,7 +148,7 @@ int npc_isnear_sub(struct block_list* bl, va_list args) {
bool npc_isnear(struct block_list * bl) {
if( battle_config.min_npc_vendchat_distance > 0 &&
map_foreachinrange(npc_isnear_sub,bl, battle_config.min_npc_vendchat_distance, BL_NPC, 0) )
map_foreachinallrange(npc_isnear_sub,bl, battle_config.min_npc_vendchat_distance, BL_NPC, 0) )
return true;
return false;
@ -242,7 +242,7 @@ int npc_enable(const char* name, int flag)
clif_changeoption(&nd->bl);
if( flag&3 && (nd->u.scr.xs >= 0 || nd->u.scr.ys >= 0) ) //check if player standing on a OnTouchArea
map_foreachinarea( npc_enable_sub, nd->bl.m, nd->bl.x-nd->u.scr.xs, nd->bl.y-nd->u.scr.ys, nd->bl.x+nd->u.scr.xs, nd->bl.y+nd->u.scr.ys, BL_PC, nd );
map_foreachinallarea( npc_enable_sub, nd->bl.m, nd->bl.x-nd->u.scr.xs, nd->bl.y-nd->u.scr.ys, nd->bl.x+nd->u.scr.xs, nd->bl.y+nd->u.scr.ys, BL_PC, nd );
return 0;
}
@ -3547,7 +3547,7 @@ void npc_unsetcells(struct npc_data* nd)
map_setcell(m, j, i, CELL_NPC, false);
//Re-deploy NPC cells for other nearby npcs.
map_foreachinarea( npc_unsetcells_sub, m, x0, y0, x1, y1, BL_NPC, nd->bl.id );
map_foreachinallarea( npc_unsetcells_sub, m, x0, y0, x1, y1, BL_NPC, nd->bl.id );
}
void npc_movenpc(struct npc_data* nd, int16 x, int16 y)
@ -3558,9 +3558,9 @@ void npc_movenpc(struct npc_data* nd, int16 x, int16 y)
x = cap_value(x, 0, map[m].xs-1);
y = cap_value(y, 0, map[m].ys-1);
map_foreachinrange(clif_outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_foreachinallrange(clif_outsight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_moveblock(&nd->bl, x, y, gettick());
map_foreachinrange(clif_insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
map_foreachinallrange(clif_insight, &nd->bl, AREA_SIZE, BL_PC, &nd->bl);
}
/// Changes the display name of the npc.

2
src/map/pc.c
View File

@ -10093,7 +10093,7 @@ static int pc_calc_pvprank_sub(struct block_list *bl,va_list ap)
return 0;
}
/*==========================================
* Calculate new rank beetween all present players (map_foreachinarea)
* Calculate new rank beetween all present players (map_foreachinallarea)
* and display result
*------------------------------------------*/
int pc_calc_pvprank(struct map_session_data *sd)

2
src/map/pet.c
View File

@ -1136,7 +1136,7 @@ static int pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, uns
if(!target && pd->loot && pd->loot->count < pd->loot->max && DIFF_TICK(tick,pd->ud.canact_tick) > 0) {
// Use half the pet's range of sight.
map_foreachinrange(pet_ai_sub_hard_lootsearch, &pd->bl, pd->db->range2 / 2, BL_ITEM, pd, &target);
map_foreachinallrange(pet_ai_sub_hard_lootsearch, &pd->bl, pd->db->range2 / 2, BL_ITEM, pd, &target);
}
if (!target) { // Just walk around.

20
src/map/script.c
View File

@ -5741,7 +5741,7 @@ BUILDIN_FUNC(areawarp)
else if( !(index=mapindex_name2id(str)) )
return SCRIPT_CMD_FAILURE;
map_foreachinarea(buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
map_foreachinallarea(buildin_areawarp_sub, m,x0,y0,x1,y1, BL_PC, index,x2,y2,x3,y3);
return SCRIPT_CMD_SUCCESS;
}
@ -5774,7 +5774,7 @@ BUILDIN_FUNC(areapercentheal)
if( (m=map_mapname2mapid(mapname))< 0)
return SCRIPT_CMD_FAILURE;
map_foreachinarea(buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
map_foreachinallarea(buildin_areapercentheal_sub,m,x0,y0,x1,y1,BL_PC,hp,sp);
return SCRIPT_CMD_SUCCESS;
}
@ -10924,7 +10924,7 @@ BUILDIN_FUNC(areaannounce)
if ((m = map_mapname2mapid(mapname)) < 0)
return SCRIPT_CMD_SUCCESS;
map_foreachinarea(buildin_announce_sub, m, x0, y0, x1, y1, BL_PC,
map_foreachinallarea(buildin_announce_sub, m, x0, y0, x1, y1, BL_PC,
mes, strlen(mes)+1, flag&BC_COLOR_MASK, fontColor, fontType, fontSize, fontAlign, fontY);
return SCRIPT_CMD_SUCCESS;
}
@ -11036,7 +11036,7 @@ BUILDIN_FUNC(getareausers)
script_pushint(st,-1);
return SCRIPT_CMD_SUCCESS;
}
map_foreachinarea(buildin_getareausers_sub,
map_foreachinallarea(buildin_getareausers_sub,
m,x0,y0,x1,y1,BL_PC,&users);
script_pushint(st,users);
return SCRIPT_CMD_SUCCESS;
@ -11083,7 +11083,7 @@ BUILDIN_FUNC(getareadropitem)
script_pushint(st,-1);
return SCRIPT_CMD_SUCCESS;
}
map_foreachinarea(buildin_getareadropitem_sub,
map_foreachinallarea(buildin_getareadropitem_sub,
m,x0,y0,x1,y1,BL_ITEM,nameid,&amount);
script_pushint(st,amount);
return SCRIPT_CMD_SUCCESS;
@ -12082,7 +12082,7 @@ BUILDIN_FUNC(addrid)
}
break;
case 4:
map_foreachinarea(buildin_addrid_sub,
map_foreachinallarea(buildin_addrid_sub,
bl->m,script_getnum(st,4),script_getnum(st,5),script_getnum(st,6),script_getnum(st,7),BL_PC,
st,script_getnum(st,3));//4-x0 , 5-y0 , 6-x1, 7-y1
break;
@ -13955,7 +13955,7 @@ BUILDIN_FUNC(playBGMall)
int x1 = script_getnum(st,6);
int y1 = script_getnum(st,7);
map_foreachinarea(playBGM_sub, map_mapname2mapid(mapname), x0, y0, x1, y1, BL_PC, name);
map_foreachinallarea(playBGM_sub, map_mapname2mapid(mapname), x0, y0, x1, y1, BL_PC, name);
}
else if( script_hasdata(st,3) ) {// entire map
const char* mapname = script_getstr(st,3);
@ -14036,7 +14036,7 @@ BUILDIN_FUNC(soundeffectall)
int y0 = script_getnum(st,6);
int x1 = script_getnum(st,7);
int y1 = script_getnum(st,8);
map_foreachinarea(soundeffect_sub, map_mapname2mapid(mapname), x0, y0, x1, y1, BL_PC, name, type);
map_foreachinallarea(soundeffect_sub, map_mapname2mapid(mapname), x0, y0, x1, y1, BL_PC, name, type);
}
else
{
@ -20161,7 +20161,7 @@ BUILDIN_FUNC(areamobuseskill)
emotion = script_getnum(st,11);
target = script_getnum(st,12);
map_foreachinrange(buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skill_id, skill_lv, casttime, cancel, emotion, target);
map_foreachinallrange(buildin_mobuseskill_sub, &center, range, BL_MOB, mobid, skill_id, skill_lv, casttime, cancel, emotion, target);
return SCRIPT_CMD_SUCCESS;
}
@ -20799,7 +20799,7 @@ BUILDIN_FUNC(cleanmap)
int16 x1 = script_getnum(st, 5);
int16 y1 = script_getnum(st, 6);
if (x0 > 0 && y0 > 0 && x1 > 0 && y1 > 0) {
map_foreachinarea(atcommand_cleanfloor_sub, m, x0, y0, x1, y1, BL_ITEM);
map_foreachinallarea(atcommand_cleanfloor_sub, m, x0, y0, x1, y1, BL_ITEM);
} else {
ShowError("cleanarea: invalid coordinate defined!\n");
return SCRIPT_CMD_FAILURE;

203
src/map/skill.c
View File

@ -3715,7 +3715,7 @@ static int skill_check_unit_range (struct block_list *bl, int x, int y, uint16 s
}
range += layout_type;
return map_foreachinarea(skill_check_unit_range_sub,bl->m,x-range,y-range,x+range,y+range,BL_SKILL,skill_id);
return map_foreachinallarea(skill_check_unit_range_sub,bl->m,x-range,y-range,x+range,y+range,BL_SKILL,skill_id);
}
static int skill_check_unit_range2_sub (struct block_list *bl, va_list ap)
@ -3796,9 +3796,9 @@ static int skill_check_unit_range2 (struct block_list *bl, int x, int y, uint16
return (!isNearNPC) ?
//!isNearNPC is used for UF_NOFOOTSET, regardless the NPC position, only check the BL_CHAR or BL_PC
map_foreachinarea(skill_check_unit_range2_sub,bl->m,x - range,y - range,x + range,y + range,type,skill_id):
map_foreachinallarea(skill_check_unit_range2_sub,bl->m,x - range,y - range,x + range,y + range,type,skill_id):
//isNearNPC is used to check range from NPC
map_foreachinarea(npc_isnear_sub,bl->m,x - range,y - range,x + range,y + range,type,skill_id);
map_foreachinallarea(npc_isnear_sub,bl->m,x - range,y - range,x + range,y + range,type,skill_id);
}
/*==========================================
@ -3965,7 +3965,7 @@ static int skill_timerskill(int tid, unsigned int tick, int id, intptr_t data)
if (skl->skill_id == SR_SKYNETBLOW) {
skill_area_temp[1] = 0;
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skl->skill_id,skl->skill_lv,DMG_SKILL);
map_foreachinrange(skill_area_sub,src,skill_get_splash(skl->skill_id,skl->skill_lv),BL_CHAR|BL_SKILL,src,
map_foreachinallrange(skill_area_sub,src,skill_get_splash(skl->skill_id,skl->skill_lv),BL_CHAR|BL_SKILL,src,
skl->skill_id,skl->skill_lv,tick,skl->flag|BCT_ENEMY|SD_SPLASH|1,skill_castend_damage_id);
break;
}
@ -4012,7 +4012,7 @@ static int skill_timerskill(int tid, unsigned int tick, int id, intptr_t data)
case BA_FROSTJOKER:
case DC_SCREAM:
range= skill_get_splash(skl->skill_id, skl->skill_lv);
map_foreachinarea(skill_frostjoke_scream,skl->map,skl->x-range,skl->y-range,
map_foreachinallarea(skill_frostjoke_scream,skl->map,skl->x-range,skl->y-range,
skl->x+range,skl->y+range,BL_CHAR,src,skl->skill_id,skl->skill_lv,tick);
break;
case PR_LEXDIVINA:
@ -4029,10 +4029,10 @@ static int skill_timerskill(int tid, unsigned int tick, int id, intptr_t data)
case NPC_EARTHQUAKE:
if( skl->type > 1 )
skill_addtimerskill(src,tick+250,src->id,0,0,skl->skill_id,skl->skill_lv,skl->type-1,skl->flag);
skill_area_temp[0] = map_foreachinrange(skill_area_sub, src, skill_get_splash(skl->skill_id, skl->skill_lv), BL_CHAR, src, skl->skill_id, skl->skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
skill_area_temp[0] = map_foreachinallrange(skill_area_sub, src, skill_get_splash(skl->skill_id, skl->skill_lv), BL_CHAR, src, skl->skill_id, skl->skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
skill_area_temp[1] = src->id;
skill_area_temp[2] = 0;
map_foreachinrange(skill_area_sub, src, skill_get_splash(skl->skill_id, skl->skill_lv), splash_target(src), src, skl->skill_id, skl->skill_lv, tick, skl->flag, skill_castend_damage_id);
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skl->skill_id, skl->skill_lv), splash_target(src), src, skl->skill_id, skl->skill_lv, tick, skl->flag, skill_castend_damage_id);
break;
case WZ_WATERBALL:
{
@ -4204,7 +4204,7 @@ static int skill_timerskill(int tid, unsigned int tick, int id, intptr_t data)
case RL_FIRE_RAIN: {
int dummy = 1, i = skill_get_splash(skl->skill_id,skl->skill_lv);
map_foreachinarea(skill_cell_overlap,src->m,skl->x-i,skl->y-i,skl->x+i,skl->y+i,BL_SKILL,skl->skill_id,&dummy,src);
map_foreachinallarea(skill_cell_overlap,src->m,skl->x-i,skl->y-i,skl->x+i,skl->y+i,BL_SKILL,skl->skill_id,&dummy,src);
skill_unitsetting(src,skl->skill_id,skl->skill_lv,skl->x,skl->y,0);
}
break;
@ -4305,7 +4305,7 @@ static int skill_active_reverberation(struct block_list *bl, va_list ap) {
if (bl->type != BL_SKILL)
return 0;
if (su->alive && (sg = su->group) && sg->skill_id == WM_REVERBERATION) {
map_foreachinrange(skill_trap_splash, bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, bl, gettick());
map_foreachinallrange(skill_trap_splash, bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, bl, gettick());
su->limit = DIFF_TICK(gettick(), sg->tick);
sg->unit_id = UNT_USED_TRAPS;
}
@ -4342,7 +4342,7 @@ void skill_reveal_trap_inarea(struct block_list *src, int range, int x, int y) {
if (!battle_config.traps_setting)
return;
nullpo_retv(src);
map_foreachinarea(skill_reveal_trap, src->m, x-range, y-range, x+range, y+range, BL_SKILL);
map_foreachinallarea(skill_reveal_trap, src->m, x-range, y-range, x+range, y+range, BL_SKILL);
}
/*========================================== [Playtester]
@ -4981,12 +4981,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
//SD_LEVEL -> Forced splash damage for Auto Blitz-Beat -> count targets
//special case: Venom Splasher uses a different range for searching than for splashing
if( flag&SD_LEVEL || skill_get_nk(skill_id)&NK_SPLASHSPLIT )
skill_area_temp[0] = map_foreachinrange(skill_area_sub, bl, (skill_id == AS_SPLASHER)?1:skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
skill_area_temp[0] = map_foreachinallrange(skill_area_sub, bl, (skill_id == AS_SPLASHER)?1:skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
// recursive invocation of skill_castend_damage_id() with flag|1
if (battle_config.skill_wall_check && skill_id != NPC_EARTHQUAKE)
map_foreachinshootrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), starget, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
else
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), starget, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
if (sd && skill_id == SU_LUNATICCARROTBEAT) {
@ -5095,9 +5092,9 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
// Splash around target cell, but only cells inside area; we first have to check the area is not negative
if((max(min_x,tx-1) <= min(max_x,tx+1)) &&
(max(min_y,ty-1) <= min(max_y,ty+1)) &&
(map_foreachinarea(skill_area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY, skill_area_sub_count))) {
(map_foreachinallarea(skill_area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY, skill_area_sub_count))) {
// Recursive call
map_foreachinarea(skill_area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, (flag|BCT_ENEMY)+1, skill_castend_damage_id);
map_foreachinallarea(skill_area_sub, bl->m, max(min_x,tx-1), max(min_y,ty-1), min(max_x,tx+1), min(max_y,ty+1), splash_target(src), src, skill_id, skill_lv, tick, (flag|BCT_ENEMY)+1, skill_castend_damage_id);
// Self-collision
if(bl->x >= min_x && bl->x <= max_x && bl->y >= min_y && bl->y <= max_y)
skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,(flag&0xFFF)>0?SD_ANIMATION:0);
@ -5137,7 +5134,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
{
skill_area_temp[1] = bl->id; //NOTE: This is used in skill_castend_nodamage_id to avoid affecting the target.
if (skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag))
map_foreachinrange(skill_area_sub,bl,
map_foreachinallrange(skill_area_sub,bl,
skill_get_splash(skill_id, skill_lv),BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,
skill_castend_nodamage_id);
@ -5364,7 +5361,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
skill_attack(BF_WEAPON,src,src,bl,skill_id,skill_lv,tick,flag);
else {
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, bl,skill_get_splash(skill_id, skill_lv),BL_CHAR,src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, bl,skill_get_splash(skill_id, skill_lv),BL_CHAR,src,skill_id,skill_lv,tick, flag|BCT_ENEMY|1,skill_castend_nodamage_id);
}
break;
case GC_DARKILLUSION:
@ -5649,7 +5646,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
status_change_end(bl, SC__SHADOWFORM, INVALID_TIMER);
sc_start(src,bl, SC_INFRAREDSCAN, 10000, skill_lv, skill_get_time(skill_id, skill_lv));
} else {
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
clif_skill_damage(src,src,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if( sd ) pc_overheat(sd,1);
}
@ -5729,7 +5726,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
if (tsc && tsc->data[SC__SHADOWFORM] && rnd() % 100 < 100 - tsc->data[SC__SHADOWFORM]->val1 * 10) // [100 - (Skill Level x 10)] %
status_change_end(bl, SC__SHADOWFORM, INVALID_TIMER);
} else {
map_foreachinshootrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
}
break;
@ -5983,7 +5980,7 @@ int skill_castend_damage_id (struct block_list* src, struct block_list *bl, uint
skill_attack(BF_WEAPON, src, src, bl, skill_id, skill_lv, tick, SD_LEVEL|flag);
} else {
skill_area_temp[1] = bl->id;
map_foreachinrange(skill_area_sub, bl,
map_foreachinallrange(skill_area_sub, bl,
sd->bonus.splash_range, BL_CHAR,
src, skill_id, skill_lv, tick, flag | BCT_ENEMY | 1,
skill_castend_damage_id);
@ -6273,7 +6270,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if (flag&1)
sc_start(src,bl,type, 23+skill_lv*4 +status_get_lv(src) -status_get_lv(bl), skill_lv,skill_get_time(skill_id,skill_lv));
else {
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
}
@ -6748,7 +6745,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
else
{
map_foreachinrange(skill_area_sub, bl,
map_foreachinallrange(skill_area_sub, bl,
skill_get_splash(skill_id, skill_lv), BL_PC,
src, skill_id, skill_lv, tick, flag|BCT_ALL|1,
skill_castend_nodamage_id);
@ -6824,7 +6821,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,skill_id,skill_lv,
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv)));
skill_reveal_trap_inarea(src, splash, src->x, src->y);
map_foreachinrange( status_change_timer_sub, src,
map_foreachinallrange( status_change_timer_sub, src,
splash, BL_CHAR, src, NULL, type, tick);
}
break;
@ -7037,10 +7034,6 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
starget = splash_target(src);
skill_area_temp[1] = 0;
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
if (battle_config.skill_wall_check)
i = map_foreachinshootrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), starget,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
else
i = map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), starget,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
if( !i && ( skill_id == NC_AXETORNADO || skill_id == SR_SKYNETBLOW || skill_id == KO_HAPPOKUNAI ) )
@ -7971,7 +7964,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
//Affect all targets on splash area.
map_foreachinrange(skill_area_sub, bl, i, BL_CHAR,
map_foreachinallrange(skill_area_sub, bl, i, BL_CHAR,
src, skill_id, skill_lv, tick, flag|1,
skill_castend_damage_id);
break;
@ -8112,7 +8105,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case BS_GREED:
if(sd){
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_greed,bl,
map_foreachinallrange(skill_greed,bl,
skill_get_splash(skill_id, skill_lv),BL_ITEM,bl);
}
break;
@ -8693,7 +8686,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id, skill_lv));
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, src,
map_foreachinallrange(skill_area_sub, src,
skill_get_splash(skill_id, skill_lv), BL_PC,
src,skill_id,skill_lv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
@ -8707,7 +8700,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id, skill_lv));
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, src,
map_foreachinallrange(skill_area_sub, src,
skill_get_splash(skill_id, skill_lv), BL_PC,
src,skill_id,skill_lv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
@ -8721,7 +8714,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src,bl,AL_HEAL,status_percent_heal(bl,90,90),1);
} else if (status_get_guild_id(src)) {
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, src,
map_foreachinallrange(skill_area_sub, src,
skill_get_splash(skill_id, skill_lv), BL_PC,
src,skill_id,skill_lv,tick, flag|BCT_GUILD|1,
skill_castend_nodamage_id);
@ -8837,7 +8830,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(bl,bl,skill_id,skill_lv,1);
clif_blown(bl);
}
map_foreachinrange(unit_changetarget,src,AREA_SIZE,BL_MOB,bl,src);
map_foreachinallrange(unit_changetarget,src,AREA_SIZE,BL_MOB,bl,src);
}
}
else if (hd && hd->master) // Failed
@ -8923,7 +8916,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
else {
skill_area_temp[2] = 0; //For SD_PREAMBLE
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, bl,
map_foreachinallrange(skill_area_sub, bl,
skill_get_splash(skill_id, skill_lv),BL_CHAR,
src,skill_id,skill_lv,tick, flag|BCT_ENEMY|SD_PREAMBLE|1,
skill_castend_nodamage_id);
@ -8935,7 +8928,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
else {
skill_area_temp[2] = 0; //For SD_PREAMBLE
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, bl,
map_foreachinallrange(skill_area_sub, bl,
skill_get_splash(skill_id, skill_lv),BL_CHAR,
src,skill_id,skill_lv,tick, flag|BCT_ENEMY|SD_PREAMBLE|1,
skill_castend_nodamage_id);
@ -8974,7 +8967,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
{
skill_area_temp[2] = 0;
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub, src,
map_foreachinallrange(skill_area_sub, src,
skill_get_splash(skill_id,skill_lv),BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_ENEMY|SD_PREAMBLE|1,
skill_castend_nodamage_id);
@ -8986,7 +8979,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
i = skill_get_splash(skill_id,skill_lv);
if( skill_id == LG_EARTHDRIVE ) {
int dummy = 1;
map_foreachinarea(skill_cell_overlap, src->m, src->x-i, src->y-i, src->x+i, src->y+i, BL_SKILL, LG_EARTHDRIVE, &dummy, src);
map_foreachinallarea(skill_cell_overlap, src->m, src->x-i, src->y-i, src->x+i, src->y+i, BL_SKILL, LG_EARTHDRIVE, &dummy, src);
}
map_foreachinrange(skill_area_sub, bl,i,BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
@ -9206,7 +9199,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if( flag&1 )
sc_start(src,bl, type, 40 + 5 * skill_lv, skill_lv, skill_get_time(skill_id, skill_lv));
else {
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
}
@ -9356,12 +9349,12 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
}
map_foreachinrange(skill_area_sub, bl, i, BL_CHAR, src, skill_id, skill_lv, tick, flag|1, skill_castend_damage_id);
map_foreachinallrange(skill_area_sub, bl, i, BL_CHAR, src, skill_id, skill_lv, tick, flag|1, skill_castend_damage_id);
break;
case AB_SILENTIUM:
// Should the level of Lex Divina be equivalent to the level of Silentium or should the highest level learned be used? [LimitLine]
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR,
src, PR_LEXDIVINA, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
break;
@ -9370,7 +9363,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if (flag&1)
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
else {
map_foreachinrange(skill_area_sub,src,skill_get_splash(skill_id, skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,(map_flag_vs(src->m)?BCT_ALL:BCT_ENEMY|BCT_SELF)|flag|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,src,skill_get_splash(skill_id, skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,(map_flag_vs(src->m)?BCT_ALL:BCT_ENEMY|BCT_SELF)|flag|1,skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
}
break;
@ -9400,14 +9393,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case WL_FROSTMISTY:
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY,skill_castend_damage_id);
map_foreachinallrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY,skill_castend_damage_id);
break;
case WL_JACKFROST:
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
else
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
break;
@ -9437,7 +9427,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if( rate ) {
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
skill_area_temp[1] = bl->id;
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
}
// Doesn't send failure packet if it fails on defense.
}
@ -9579,7 +9569,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_damage(src,bl,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
if (map_flag_vs(src->m)) // Doesn't affect the caster in non-PVP maps [exneval]
sc_start2(src,bl,type,100,skill_lv,src->id,skill_get_time(skill_id,skill_lv));
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),splash_target(src),src,skill_id,skill_lv,tick,flag|BCT_ENEMY|SD_SPLASH|1,skill_castend_damage_id);
map_foreachinallrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),splash_target(src),src,skill_id,skill_lv,tick,flag|BCT_ENEMY|SD_SPLASH|1,skill_castend_damage_id);
if (sd)
pc_overheat(sd,1);
break;
@ -9651,7 +9641,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src, bl, SC_BLIND, 53 + 2 * skill_lv, skill_lv, skill_get_time2(skill_id, skill_lv));
} else {
clif_skill_nodamage(src, bl, skill_id, 0, 1);
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR,
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
}
break;
@ -9701,7 +9691,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case LG_TRAMPLE:
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
if (rnd()%100 < (25 + 25 * skill_lv))
map_foreachinrange(skill_destroy_trap,bl,skill_get_splash(skill_id,skill_lv),BL_SKILL,tick);
map_foreachinallrange(skill_destroy_trap,bl,skill_get_splash(skill_id,skill_lv),BL_SKILL,tick);
status_change_end(bl, SC_SV_ROOTTWIST, INVALID_TIMER);
break;
@ -9796,7 +9786,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
case 2: // Splash AoE Lex Divina
sc_start(src,bl,SC_SHIELDSPELL_MDEF,100,opt,shield_mdef * 2000);
clif_skill_damage(src,src,tick,status_get_amotion(src),0,-30000,1,skill_id,skill_lv,DMG_SKILL);
map_foreachinrange(skill_area_sub,src,splashrange,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,src,splashrange,BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
break;
case 3: // Casts Magnificat.
if (sc_start(src,bl,SC_SHIELDSPELL_MDEF,100,opt,shield_mdef * 30000))
@ -9836,7 +9826,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
else {
skill_area_temp[2] = 0;
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_PC,src,skill_id,skill_lv,tick,flag|SD_PREAMBLE|BCT_PARTY|BCT_SELF|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_PC,src,skill_id,skill_lv,tick,flag|SD_PREAMBLE|BCT_PARTY|BCT_SELF|1,skill_castend_nodamage_id);
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
}
break;
@ -9896,7 +9886,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src, bl, skill_id, skill_lv, i ? 1:0);
} else {
clif_skill_damage(src,bl,tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF|SD_SPLASH|1, skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), splash_target(src), src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF|SD_SPLASH|1, skill_castend_nodamage_id);
}
break;
@ -9998,7 +9988,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if( flag&1 )
sc_start(src,bl,type,100,skill_lv,skill_get_time(skill_id,skill_lv));
else {
map_foreachinrange(skill_area_sub,src,skill_get_splash(skill_id,skill_lv),BL_PC,src,skill_id,skill_lv,tick,flag|BCT_ALL|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,src,skill_get_splash(skill_id,skill_lv),BL_PC,src,skill_id,skill_lv,tick,flag|BCT_ALL|1,skill_castend_nodamage_id);
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
}
break;
@ -10010,7 +10000,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
// Success chance: (Skill Level x 6) + (Voice Lesson Skill Level x 2) + (Caster's Job Level / 2) %
skill_area_temp[5] = skill_lv * 6 + ((sd) ? pc_checkskill(sd, WM_LESSON) : 1) * 2 + (sd ? sd->status.job_level : 50) / 2;
skill_area_temp[6] = skill_get_time(skill_id,skill_lv);
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ALL|BCT_WOS|1, skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ALL|BCT_WOS|1, skill_castend_nodamage_id);
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
}
break;
@ -10041,12 +10031,12 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_fail(sd,skill_id,USESKILL_FAIL_NEED_HELPER,0);
break;
}
if( map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id,skill_lv),
if( map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id,skill_lv),
BL_PC, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count) > 7 )
flag |= 2;
else
flag |= 1;
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv),BL_PC, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF, skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv),BL_PC, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|BCT_SELF, skill_castend_nodamage_id);
clif_skill_nodamage(src, bl, skill_id, skill_lv,
sc_start(src,src,SC_STOP,100,skill_lv,skill_get_time2(skill_id,skill_lv)));
if( flag&2 ) // Dealed here to prevent conflicts
@ -10075,7 +10065,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start2(src,bl,type,100,skill_lv,chorusbonus,skill_get_time(skill_id,skill_lv));
} else { // These affect to all targets arround the caster.
if( rnd()%100 < 15 + 5 * skill_lv * 5 * chorusbonus ) {
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv),BL_PC, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id,skill_lv),BL_PC, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
clif_skill_nodamage(src,bl,skill_id,skill_lv,1);
}
}
@ -10238,7 +10228,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
sc_start(src, bl, type, rate, skill_lv, duration);
} else {
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ALL|BCT_WOS|1, skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ALL|BCT_WOS|1, skill_castend_nodamage_id);
}
break;
@ -10363,7 +10353,7 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
status_zap(bl,0,status_get_max_sp(bl) * (25 + 5 * skill_lv) / 100);
}
} else {
map_foreachinrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
map_foreachinallrange(skill_area_sub,bl,skill_get_splash(skill_id,skill_lv),BL_CHAR,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_nodamage_id);
clif_skill_nodamage(src,src,skill_id,skill_lv,1);
}
break;
@ -10578,9 +10568,6 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
}else{
skill_area_temp[2] = 0;
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_nodamage_id);
else
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR|BL_SKILL, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_nodamage_id);
}
break;
@ -10736,18 +10723,12 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
break;
case RL_D_TAIL:
if (sd) {
if (battle_config.skill_wall_check)
skill_area_temp[0] = map_foreachinshootrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
else
skill_area_temp[0] = map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
if (!skill_area_temp[0]) {
clif_skill_fail(sd, skill_id, USESKILL_FAIL_LEVEL, 0);
break;
}
}
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|SD_ANIMATION|1, skill_castend_damage_id);
else
map_foreachinrange(skill_area_sub, bl, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|SD_ANIMATION|1, skill_castend_damage_id);
skill_area_temp[0] = 0;
break;
@ -10755,12 +10736,9 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
if (sd) {
skill_area_temp[1] = bl->id;
// Check surrounding
if (battle_config.skill_wall_check)
skill_area_temp[0] = map_foreachinshootrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
else
skill_area_temp[0] = map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, BCT_ENEMY, skill_area_sub_count);
if (skill_area_temp[0])
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
map_foreachinallrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
// Main target always receives damage
clif_skill_nodamage(src, src, skill_id, skill_lv, 1);
@ -10770,9 +10748,6 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
}
else {
clif_skill_nodamage(src, src, skill_id, skill_lv, 1);
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
else
map_foreachinrange(skill_area_sub, src, skill_get_splash(skill_id, skill_lv), BL_CHAR, src, skill_id, skill_lv, tick, flag|BCT_ENEMY|SD_SPLASH|1, skill_castend_damage_id);
}
skill_area_temp[0] = 0;
@ -10786,11 +10761,11 @@ int skill_castend_nodamage_id (struct block_list *src, struct block_list *bl, ui
clif_skill_nodamage(src, bl, skill_id, skill_lv, 1);
// Detonate RL_B_TRAP
if ((i = pc_checkskill(sd, RL_B_TRAP))) {
map_foreachinrange(skill_bind_trap, src, AREA_SIZE, BL_SKILL, src);
map_foreachinallrange(skill_bind_trap, src, AREA_SIZE, BL_SKILL, src);
}
// Detonate RL_H_MINE
if ((i = pc_checkskill(sd, RL_H_MINE)))
map_foreachinrange(skill_area_sub, src, splash, BL_CHAR, src, RL_H_MINE, i, tick, flag|BCT_ENEMY|SD_SPLASH, skill_castend_damage_id);
map_foreachinallrange(skill_area_sub, src, splash, BL_CHAR, src, RL_H_MINE, i, tick, flag|BCT_ENEMY|SD_SPLASH, skill_castend_damage_id);
sd->flicker = false;
}
break;
@ -11511,11 +11486,11 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case PR_BENEDICTIO:
skill_area_temp[1] = src->id;
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub,
map_foreachinallarea(skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_PC,
src, skill_id, skill_lv, tick, flag|BCT_ALL|1,
skill_castend_nodamage_id);
map_foreachinarea(skill_area_sub,
map_foreachinallarea(skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1,
skill_castend_damage_id);
@ -11523,7 +11498,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case BS_HAMMERFALL:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub,
map_foreachinallarea(skill_area_sub,
src->m, x-i, y-i, x+i, y+i, BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|2,
skill_castend_nodamage_id);
@ -11531,7 +11506,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case HT_DETECTING:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea( status_change_timer_sub,
map_foreachinallarea( status_change_timer_sub,
src->m, x-i, y-i, x+i,y+i,BL_CHAR,
src,NULL,SC_SIGHT,tick);
skill_reveal_trap_inarea(src, i, x, y);
@ -11539,7 +11514,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case SR_RIDEINLIGHTNING:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub, src->m, x-i, y-i, x+i, y+i, BL_CHAR,
map_foreachinallarea(skill_area_sub, src->m, x-i, y-i, x+i, y+i, BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_damage_id);
break;
@ -11704,7 +11679,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
break;
case RG_CLEANER: // [Valaris]
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_graffitiremover,src->m,x-i,y-i,x+i,y+i,BL_SKILL,1);
map_foreachinallarea(skill_graffitiremover,src->m,x-i,y-i,x+i,y+i,BL_SKILL,1);
break;
case SO_WARMER:
@ -11811,7 +11786,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
if(potion_hp > 0 || potion_sp > 0) {
i_lv = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub,
map_foreachinallarea(skill_area_sub,
src->m,x-i_lv,y-i_lv,x+i_lv,y+i_lv,BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_PARTY|BCT_GUILD|1,
skill_castend_nodamage_id);
@ -11832,7 +11807,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
if(potion_hp > 0 || potion_sp > 0) {
id = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub,
map_foreachinallarea(skill_area_sub,
src->m,x-id,y-id,x+id,y+id,BL_CHAR,
src,skill_id,skill_lv,tick,flag|BCT_PARTY|BCT_GUILD|1,
skill_castend_nodamage_id);
@ -11845,7 +11820,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
int dummy = 1;
clif_skill_poseffect(src,skill_id,skill_lv,x,y,tick);
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_cell_overlap, src->m, x-i, y-i, x+i, y+i, BL_SKILL, HW_GANBANTEIN, &dummy, src);
map_foreachinallarea(skill_cell_overlap, src->m, x-i, y-i, x+i, y+i, BL_SKILL, HW_GANBANTEIN, &dummy, src);
} else {
if (sd) clif_skill_fail(sd,skill_id,USESKILL_FAIL_LEVEL,0);
return 1;
@ -11938,15 +11913,12 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
skill_area_temp[4] = x;
skill_area_temp[5] = y;
i = skill_get_splash(skill_id,skill_lv);
if (battle_config.skill_wall_check)
map_foreachinshootarea(skill_area_sub,src->m,x-i,y-i,x+i,y+i,BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
else
map_foreachinarea(skill_area_sub,src->m,x-i,y-i,x+i,y+i,BL_CHAR|BL_SKILL,src,skill_id,skill_lv,tick,flag|BCT_ENEMY|1,skill_castend_damage_id);
break;
case SO_ARRULLO:
i = skill_get_splash(skill_id,skill_lv);
map_foreachinarea(skill_area_sub,src->m,x-i,y-i,x+i,y+i,BL_CHAR,
map_foreachinallarea(skill_area_sub,src->m,x-i,y-i,x+i,y+i,BL_CHAR,
src, skill_id, skill_lv, tick, flag|BCT_ENEMY|1, skill_castend_nodamage_id);
break;
@ -11963,7 +11935,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case AB_EPICLESIS:
if( (sg = skill_unitsetting(src, skill_id, skill_lv, x, y, 0)) ) {
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_area_sub, src->m, x - i, y - i, x + i, y + i, BL_CHAR, src, ALL_RESURRECTION, 1, tick, flag|BCT_NOENEMY|1,skill_castend_nodamage_id);
map_foreachinallarea(skill_area_sub, src->m, x - i, y - i, x + i, y + i, BL_CHAR, src, ALL_RESURRECTION, 1, tick, flag|BCT_NOENEMY|1,skill_castend_nodamage_id);
}
break;
@ -11996,7 +11968,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case RA_DETONATOR:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_detonator, src->m, x-i, y-i, x+i, y+i, BL_SKILL, src);
map_foreachinallarea(skill_detonator, src->m, x-i, y-i, x+i, y+i, BL_SKILL, src);
clif_skill_damage(src, src, tick, status_get_amotion(src), 0, -30000, 1, skill_id, skill_lv, DMG_SKILL);
break;
@ -12041,7 +12013,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
return 1;
}
// Release all targets against the caster.
map_foreachinrange(skill_mob_releasetarget, src, AREA_SIZE, BL_MOB, src, &group->unit->bl);
map_foreachinallrange(skill_mob_releasetarget, src, AREA_SIZE, BL_MOB, src, &group->unit->bl);
skill_blown(src, src, skill_get_blewcount(skill_id, skill_lv), unit_getdir(src), BLOWN_IGNORE_NO_KNOCKBACK); // Don't stop the caster from backsliding if special_state.no_knockback is active
clif_skill_nodamage(src,src,skill_id,skill_lv,sc_start(src,src,type,100,skill_lv,skill_get_time2(skill_id,skill_lv)));
}
@ -12086,7 +12058,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
case WM_DOMINION_IMPULSE:
i = skill_get_splash(skill_id, skill_lv);
map_foreachinarea(skill_active_reverberation, src->m, x-i, y-i, x+i,y+i,BL_SKILL);
map_foreachinallarea(skill_active_reverberation, src->m, x-i, y-i, x+i,y+i,BL_SKILL);
break;
case WM_GREAT_ECHO:
@ -12126,7 +12098,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
ud->skillunit[i_su]->unit->group->val2 = skill_lv;
break;
case 2:
map_foreachinarea(skill_area_sub,src->m,
map_foreachinallarea(skill_area_sub,src->m,
ud->skillunit[i_su]->unit->bl.x - 2,ud->skillunit[i_su]->unit->bl.y - 2,
ud->skillunit[i_su]->unit->bl.x + 2,ud->skillunit[i_su]->unit->bl.y + 2, BL_CHAR,
src, GN_DEMONIC_FIRE, skill_lv + 20, tick, flag|BCT_ENEMY|SD_LEVEL|1, skill_castend_damage_id);
@ -12146,7 +12118,7 @@ int skill_castend_pos2(struct block_list* src, int x, int y, uint16 skill_id, ui
int acid_lv = 5; // Cast at Acid Demonstration at level 5 unless the user has a higher level learned.
if( sd && pc_checkskill(sd, CR_ACIDDEMONSTRATION) > 5 )
acid_lv = pc_checkskill(sd, CR_ACIDDEMONSTRATION);
map_foreachinarea(skill_area_sub, src->m,
map_foreachinallarea(skill_area_sub, src->m,
ud->skillunit[i_su]->unit->bl.x - 2, ud->skillunit[i_su]->unit->bl.y - 2,
ud->skillunit[i_su]->unit->bl.x + 2, ud->skillunit[i_su]->unit->bl.y + 2, BL_CHAR,
src, GN_FIRE_EXPANSION_ACID, acid_lv, tick, flag|BCT_ENEMY|SD_LEVEL|1, skill_castend_damage_id);
@ -13679,7 +13651,7 @@ int skill_unit_onplace_timer(struct skill_unit *unit, struct block_list *bl, uns
map_moveblock(bl, unit->bl.x, unit->bl.y, tick);
clif_fixpos(bl);
}
map_foreachinrange(skill_trap_splash, &unit->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &unit->bl, tick);
map_foreachinallrange(skill_trap_splash, &unit->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &unit->bl, tick);
sg->unit_id = UNT_USED_TRAPS; //Changed ID so it does not invoke a for each in area again.
}
break;
@ -13719,9 +13691,6 @@ int skill_unit_onplace_timer(struct skill_unit *unit, struct block_list *bl, uns
break;
if (sg->unit_id == UNT_FIRINGTRAP || sg->unit_id == UNT_ICEBOUNDTRAP || sg->unit_id == UNT_CLAYMORETRAP)
bl_flag = bl_flag|BL_SKILL|~BCT_SELF;
if(battle_config.skill_wall_check && !(skill_get_nk(skill_id)&NK_NO_DAMAGE))
map_foreachinshootrange(skill_trap_splash, &unit->bl, skill_get_splash(sg->skill_id, sg->skill_lv), bl_flag, &unit->bl, tick);
else
map_foreachinrange(skill_trap_splash, &unit->bl, skill_get_splash(sg->skill_id, sg->skill_lv), bl_flag, &unit->bl, tick);
if (sg->unit_id != UNT_FIREPILLAR_ACTIVE)
clif_changetraplook(&unit->bl,(sg->unit_id == UNT_LANDMINE ? UNT_FIREPILLAR_ACTIVE : UNT_USED_TRAPS));
@ -14621,7 +14590,7 @@ int skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint16
//Else: new search for partners.
c = 0;
memset (p_sd, 0, sizeof(p_sd));
i = map_foreachinrange(skill_check_condition_char_sub, &sd->bl, range, BL_PC, &sd->bl, &c, &p_sd, skill_id);
i = map_foreachinallrange(skill_check_condition_char_sub, &sd->bl, range, BL_PC, &sd->bl, &c, &p_sd, skill_id);
if ( skill_id != PR_BENEDICTIO && skill_id != AB_ADORAMUS && skill_id != WL_COMET ) //Apply the average lv to encore skills.
*skill_lv = (i+(*skill_lv))/(c+1); //I know c should be one, but this shows how it could be used for the average of n partners.
@ -15084,7 +15053,7 @@ bool skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_i
return false;
}
}
if( map_foreachinrange(skill_count_wos, &sd->bl, range, BL_ALL, &sd->bl) ) {
if( map_foreachinallrange(skill_count_wos, &sd->bl, range, BL_ALL, &sd->bl) ) {
clif_skill_fail(sd,skill_id,USESKILL_FAIL,0);
return false;
}
@ -15367,7 +15336,7 @@ bool skill_check_condition_castbegin(struct map_session_data* sd, uint16 skill_i
break;
case SR_CURSEDCIRCLE:
if (map_flag_gvg2(sd->bl.m)) {
if (map_foreachinrange(mob_count_sub, &sd->bl, skill_get_splash(skill_id, skill_lv), BL_MOB,
if (map_foreachinallrange(mob_count_sub, &sd->bl, skill_get_splash(skill_id, skill_lv), BL_MOB,
MOBID_EMPERIUM, MOBID_GUARDIAN_STONE1, MOBID_GUARDIAN_STONE2)) {
char output[128];
@ -16833,11 +16802,11 @@ int skill_sit (struct map_session_data *sd, int type)
if (!flag) return 0;
if(type) {
if (map_foreachinrange(skill_sit_count,&sd->bl, range, BL_PC, flag) > 1)
map_foreachinrange(skill_sit_in,&sd->bl, range, BL_PC, flag);
if (map_foreachinallrange(skill_sit_count,&sd->bl, range, BL_PC, flag) > 1)
map_foreachinallrange(skill_sit_in,&sd->bl, range, BL_PC, flag);
} else {
if (map_foreachinrange(skill_sit_count,&sd->bl, range, BL_PC, flag) < 2)
map_foreachinrange(skill_sit_out,&sd->bl, range, BL_PC, flag);
if (map_foreachinallrange(skill_sit_count,&sd->bl, range, BL_PC, flag) < 2)
map_foreachinallrange(skill_sit_out,&sd->bl, range, BL_PC, flag);
}
return 0;
}
@ -17102,15 +17071,9 @@ int skill_detonator(struct block_list *bl, va_list ap)
case UNT_CLAYMORETRAP:
case UNT_FIRINGTRAP:
case UNT_ICEBOUNDTRAP:
if (battle_config.skill_wall_check)
map_foreachinshootrange(skill_trap_splash,bl,skill_get_splash(unit->group->skill_id,unit->group->skill_lv),unit->group->bl_flag|BL_SKILL|~BCT_SELF,bl,unit->group->tick);
else
map_foreachinrange(skill_trap_splash,bl,skill_get_splash(unit->group->skill_id,unit->group->skill_lv),unit->group->bl_flag|BL_SKILL|~BCT_SELF,bl,unit->group->tick);
break;
default:
if(battle_config.skill_wall_check && !(skill_get_nk(unit->group->skill_id)&NK_NO_DAMAGE))
map_foreachinshootrange(skill_trap_splash,bl,skill_get_splash(unit->group->skill_id,unit->group->skill_lv),unit->group->bl_flag,bl,unit->group->tick);
else
map_foreachinrange(skill_trap_splash,bl,skill_get_splash(unit->group->skill_id,unit->group->skill_lv),unit->group->bl_flag,bl,unit->group->tick);
break;
}
@ -17141,7 +17104,7 @@ static int skill_bind_trap(struct block_list *bl, va_list ap) {
if (su->group->unit_id != UNT_B_TRAP || su->group->src_id != src->id )
return 0;
map_foreachinrange(skill_trap_splash, bl, su->range, BL_CHAR, bl,su->group->tick);
map_foreachinallrange(skill_trap_splash, bl, su->range, BL_CHAR, bl,su->group->tick);
clif_changetraplook(bl, UNT_USED_TRAPS);
su->group->unit_id = UNT_USED_TRAPS;
su->group->limit = DIFF_TICK(gettick(), su->group->tick) + 500;
@ -17625,7 +17588,7 @@ void skill_getareachar_skillunit_visibilty(struct skill_unit *su, enum send_targ
clif_getareachar_skillunit(&su->bl, su, target, true);
else {
struct block_list *src = battle_get_master(&su->bl);
map_foreachinarea(skill_getareachar_skillunit_visibilty_sub, su->bl.m, su->bl.x-AREA_SIZE, su->bl.y-AREA_SIZE,
map_foreachinallarea(skill_getareachar_skillunit_visibilty_sub, su->bl.m, su->bl.x-AREA_SIZE, su->bl.y-AREA_SIZE,
su->bl.x+AREA_SIZE, su->bl.y+AREA_SIZE, BL_PC, su, src, status_get_party_id(src));
}
}
@ -18406,9 +18369,6 @@ static int skill_unit_timer_sub(DBKey key, DBData *data, va_list ap)
if( unit->range >= 0 && group->interval != -1 )
{
if( battle_config.skill_wall_check )
map_foreachinshootrange(skill_unit_timer_sub_onplace, bl, unit->range, group->bl_flag, bl,tick);
else
map_foreachinrange(skill_unit_timer_sub_onplace, bl, unit->range, group->bl_flag, bl,tick);
if(unit->range == -1) //Unit disabled, but it should not be deleted yet.
@ -19794,9 +19754,6 @@ static int skill_destroy_trap(struct block_list *bl, va_list ap)
case UNT_CLAYMORETRAP:
case UNT_FIRINGTRAP:
case UNT_ICEBOUNDTRAP:
if(battle_config.skill_wall_check)
map_foreachinshootrange(skill_trap_splash,&su->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag|BL_SKILL|~BCT_SELF, &su->bl,tick);
else
map_foreachinrange(skill_trap_splash,&su->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag|BL_SKILL|~BCT_SELF, &su->bl,tick);
break;
case UNT_LANDMINE:
@ -19809,7 +19766,7 @@ static int skill_destroy_trap(struct block_list *bl, va_list ap)
if (battle_config.skill_wall_check && !(skill_get_nk(sg->skill_id)&NK_NO_DAMAGE))
map_foreachinshootrange(skill_trap_splash,&su->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &su->bl,tick);
else
map_foreachinrange(skill_trap_splash,&su->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &su->bl,tick);
map_foreachinallrange(skill_trap_splash,&su->bl, skill_get_splash(sg->skill_id, sg->skill_lv), sg->bl_flag, &su->bl,tick);
break;
}
// Traps aren't recovered.

8
src/map/status.c
View File

@ -11843,7 +11843,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
int range = 1
+ skill_get_range2(bl, status_sc2skill(type), sce->val1, true)
+ skill_get_range2(bl, TF_BACKSLIDING, 1, true); // Since most people use this to escape the hold....
map_foreachinarea(status_change_timer_sub,
map_foreachinallarea(status_change_timer_sub,
bl->m, bl->x-range, bl->y-range, bl->x+range,bl->y+range,BL_CHAR,bl,sce,type,gettick());
}
break;
@ -12008,7 +12008,7 @@ int status_change_end_(struct block_list* bl, enum sc_type type, int tid, const
break;
case SC_CURSEDCIRCLE_ATKER:
if( sce->val2 ) // Used the default area size cause there is a chance the caster could knock back and can't clear the target.
map_foreachinrange(status_change_timer_sub, bl, AREA_SIZE + 3, BL_CHAR, bl, sce, SC_CURSEDCIRCLE_TARGET, gettick());
map_foreachinallrange(status_change_timer_sub, bl, AREA_SIZE + 3, BL_CHAR, bl, sce, SC_CURSEDCIRCLE_TARGET, gettick());
break;
case SC_RAISINGDRAGON:
if( sd && sce->val2 && !pc_isdead(sd) ) {
@ -12445,9 +12445,9 @@ int status_change_timer(int tid, unsigned int tick, int id, intptr_t data)
//Restore trap immunity
if(sce->val4%2)
sce->val4--;
map_foreachinrange( status_change_timer_sub, bl, sce->val3, BL_CHAR|BL_SKILL, bl, sce, type, tick);
map_foreachinallrange( status_change_timer_sub, bl, sce->val3, BL_CHAR|BL_SKILL, bl, sce, type, tick);
} else {
map_foreachinrange( status_change_timer_sub, bl, sce->val3, BL_CHAR, bl, sce, type, tick);
map_foreachinallrange( status_change_timer_sub, bl, sce->val3, BL_CHAR, bl, sce, type, tick);
skill_reveal_trap_inarea(bl, sce->val3, bl->x, bl->y);
}