all: char-server

txt: char-server

COMMON_H = ../common/core.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/db.h ../common/lock.h ../common/timer.h ../common/malloc.h ../common/showmsg.h ../common/strlib.h

char-server: char.o inter.o int_party.o int_guild.o int_storage.o int_pet.o $(COMMON_OBJ)

$(CC) -o ../../$@ $> $(LIB_S)

all: char-server_sql

sql: char-server_sql

COMMON_H = ../common/core.h ../common/socket.h ../common/timer.h ../common/db.h ../common/malloc.h ../common/showmsg.h ../common/utils.h ../common/strlib.h

char-server_sql: char.o inter.o int_party.o int_guild.o int_storage.o int_pet.o itemdb.o $(COMMON_OBJ)

clean:

#include <signal.h>

#include <string.h>

#ifdef DUMPSTACK

#endif

#include "../common/mmo.h"

#include "core.h"

#include "socket.h"

#include "timer.h"

* Dumps the stack using glibc's backtrace

*-----------------------------------------

*/

static void sig_dump(int sn)

{

// When pass the signal to the system's default handler

compat_signal(sn, SIG_DFL);

raise(sn);

}

int get_svn_revision(char *svnentry) { // Warning: minor syntax checking

char line[1024];

compat_signal(SIGPIPE,SIG_IGN);

compat_signal(SIGTERM,sig_proc);

compat_signal(SIGINT,sig_proc);

compat_signal(SIGSEGV, sig_dump);

compat_signal(SIGFPE, sig_dump);

compat_signal(SIGILL, sig_dump);

#ifndef _WIN32

compat_signal(SIGBUS, sig_dump);

#endif

display_title();

tick_ = time(0);

do_init(argc,argv);

do_sendrecv(next);

do_parsepacket();

}

return 0;

}

return h;

}

{

int i;

struct dbt* table;

table->maxlen=maxlen;

for(i=0;i<HASH_SIZE;i++)

table->ht[i]=NULL;

return table;

}

return (unsigned int)a;

}

{

int i;

struct dbt* table;

table->maxlen=sizeof(int);

for(i=0;i<HASH_SIZE;i++)

table->ht[i]=NULL;

return table;

}

db_rebalance(p,&table->ht[hash]);

}

}

return p;

}

#else

aFree(p);

#endif

return data;

}

void db_foreach(struct dbt *table,int (*func)(void*,void*,va_list),...)

{

int i,sp;

// red-black tree�Ȃ̂�64��stack�������2^32�ƒm�[�h�܂ő��v

struct dbn *p,*pn,*stack[64];

va_list ap;

// printf("Warning: no data for key %d in db_foreach (db.c) !\n",(int)p->key);

//} else {

func(p->key, p->data, ap);

//}

if((pn=p->left)!=NULL){

if(p->right){

}

}

}

va_end(ap);

}

void (*release)(struct dbn*,int which);

int maxlen;

struct dbn *ht[HASH_SIZE];

};

#define strdb_search(t,k) db_search((t),(void*)(k))

#define numdb_erase(t,k) db_erase ((t),(void*)(k))

#define numdb_foreach db_foreach

#define numdb_final db_final

void* db_search(struct dbt *table,void* key);

void* db_search2(struct dbt *table, const char *key); // [MouseJstr]

struct dbn* db_insert(struct dbt *table,void* key,void* data);

#include "malloc.h"

#ifdef _WIN32

#else

#define zlib_inflateInit inflateInit

#define zlib_inflate inflate

#define zlib_inflateEnd inflateEnd

}

gentry_table = NULL;

gentry_entrys = gentry_maxentry = 0;

}

/*==========================================

int result = 0, result2 = 0, result3 = 0, result4 = 0;

#ifdef _WIN32

if(!zlib_dll) {

zlib_dll = LoadLibrary("zlib.dll");

(FARPROC)zlib_inflateInit_ = GetProcAddress(zlib_dll,"inflateInit_");

exit(1);

}

}

#endif

data_conf = fopen(fname, "r");

#include <string.h>

#include "malloc.h"

void* aMalloc_( size_t size, const char *file, int line, const char *func )

{

void *ret;

// printf("%s:%d: in func %s: malloc %d\n",file,line,func,size);

ret=malloc(size);

if(ret==NULL){

printf("%s:%d: in func %s: malloc error out of memory!\n",file,line,func);

exit(1);

void *ret;

// printf("%s:%d: in func %s: calloc %d %d\n",file,line,func,num,size);

ret=calloc(num,size);

if(ret==NULL){

printf("%s:%d: in func %s: calloc error out of memory!\n",file,line,func);

exit(1);

void *ret;

// printf("%s:%d: in func %s: realloc %p %d\n",file,line,func,p,size);

ret=realloc(p,size);

if(ret==NULL){

printf("%s:%d: in func %s: realloc error out of memory!\n",file,line,func);

exit(1);

return ret;

}

#endif

void * _bcallocA(size_t size, size_t cnt) {

void *ret = aMallocA(size * cnt);

memset(ret, 0, size * cnt);

return ret;

}

char * _bstrdup(const char *chr) {

int len = strlen(chr);

strcpy(ret, chr);

return ret;

}

void* aMalloc_( size_t size, const char *file, int line, const char *func );

void* aCalloc_( size_t num, size_t size, const char *file, int line, const char *func );

void* aRealloc_( void *p, size_t size, const char *file, int line, const char *func );

# define aMalloc(n) aMalloc_(n,ALC_MARK)

# define aMallocA(n) aMalloc_(n,ALC_MARK)

# define aCalloc(m,n) aCalloc_(m,n,ALC_MARK)

# define aCallocA(m,n) aCalloc_(m,n,ALC_MARK)

# define aRealloc(p,n) aRealloc_(p,n,ALC_MARK)

#endif

#endif

txt: ladmin

sql: ladmin

COMMON_H = ../common/core.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h ../common/db.h ../common/malloc.h ../common/showmsg.h ../common/strlib.h

ladmin: ladmin.o md5calc.o $(COMMON_OBJ)

all: login-server

txt: login-server

COMMON_H = ../common/core.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h ../common/db.h ../common/lock.h ../common/malloc.h ../common/showmsg.h ../common/strlib.h

login-server: login.o md5calc.o $(COMMON_OBJ)

sql: login-server_sql

shared_libs=all

COMMON_H = ../common/core.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h ../common/db.h ../common/malloc.h ../common/showmsg.h ../common/strlib.h

login-server_sql: login.o md5calc.o $(COMMON_OBJ)

sqlobj:

mkdir sqlobj

LIBS = -lz -lm

map-server: txtobj/map.o txtobj/chrif.o txtobj/clif.o txtobj/pc.o txtobj/status.o txtobj/npc.o txtobj/npc_chat.o txtobj/chat.o txtobj/path.o txtobj/itemdb.o txtobj/mob.o txtobj/script.o txtobj/storage.o txtobj/skill.o txtobj/atcommand.o txtobj/charcommand.o txtobj/battle.o txtobj/intif.o txtobj/trade.o txtobj/party.o txtobj/vending.o txtobj/guild.o txtobj/pet.o txtobj/log.o $(COMMON_OBJ)

sqlobj/%.o: %.c

$(COMPILE.c) $(OUTPUT_OPTION) $<

clean:

rm -rf *.o ../../map-server ../../map-server_sql sqlobj txtobj

#include "../common/timer.h"

#include "../common/nullpo.h"

#include "../common/mmo.h"

#include "log.h"

#include "clif.h"

ACMD_FUNC(misceffect); // by MC Cameri

ACMD_FUNC(mobsearch);

ACMD_FUNC(cleanmap);

ACMD_FUNC(autoloot); // by Upa-Kun

#ifndef TXT_ONLY

{ AtCommand_MiscEffect, "@misceffect", 50, atcommand_misceffect }, // by MC Cameri

{ AtCommand_MobSearch, "@mobsearch", 0, atcommand_mobsearch },

{ AtCommand_CleanMap, "@cleanmap", 0, atcommand_cleanmap },

#ifndef TXT_ONLY // sql-only commands

{ AtCommand_CheckMail, "@checkmail", 1, atcommand_listmail }, // [Valaris]

clif_displaymessage(fd, output);

}

return 0;

}

}

/*==========================================

*

*------------------------------------------

*/

AtCommand_MiscEffect, // by MC Cameri

AtCommand_MobSearch,

AtCommand_CleanMap,

// SQL-only commands start

#ifndef TXT_ONLY

// �_���[�W�̒x��

struct battle_delay_damage_ {

int damage;

int flag;

};

int battle_delay_damage_sub(int tid,unsigned int tick,int id,int data)

{

struct battle_delay_damage_ *dat=(struct battle_delay_damage_ *)data;

aFree(dat);

return 0;

}

dat->src=src;

dat->damage=damage;

dat->flag=flag;

add_timer(tick,battle_delay_damage_sub,src->id,(int)dat);

flag&BF_SHORT && skill_num != NPC_GUIDEDATTACK) {

// �Z�[�t�e�B�E�H�[��

struct skill_unit *unit;

if (unit) {

if (unit->group && (--unit->group->val2)<=0)

skill_delunit(unit);

if(sd && sd->splash_range > 0 && (wd.damage > 0 || wd.damage2 > 0) )

skill_castend_damage_id(src,target,0,-1,tick,0);

map_freeblock_lock();

if(target->prev != NULL &&

(target->type != BL_PC || (target->type == BL_PC && !pc_isdead((struct map_session_data *)target) ) ) ) {

if(wd.damage > 0 || wd.damage2 > 0) {

}

if(rdamage > 0)

if(t_sc_data && t_sc_data[SC_AUTOCOUNTER].timer != -1 && t_sc_data[SC_AUTOCOUNTER].val4 > 0) {

if(t_sc_data[SC_AUTOCOUNTER].val3 == src->id)

battle_weapon_attack(target,src,tick,0x8000|t_sc_data[SC_AUTOCOUNTER].val1);

ShowWarning(tmp_output);

clif_foreachclient(chrif_disconnect_sub);

chrif_connected = 0;

}

close(fd);

return 0;

if (chrif_isconnect()) displayed = 0;

return 0;

}

/*==========================================

*

int chrif_chardisconnect(struct map_session_data *sd);

int check_connect_char_server(int tid, unsigned int tick, int id, int data);

int do_init_chrif(void);

int chrif_flush_fifo(void);

// �C�x���g�̔���

if( (ev=numdb_search(guild_infoevent_db,sg->guild_id))!=NULL ){

numdb_erase(guild_infoevent_db,sg->guild_id);

npc_event_do(ev->name);

}

}

}

if( (ev=numdb_search(guild_castleinfoevent_db,code))!=NULL ){

numdb_erase(guild_castleinfoevent_db,code);

npc_event_do(ev->name);

}

}

return 1;

id->equip_script = parse_script((unsigned char *) p,lines);

}

fclose(fp);

ln=0; // reset to 0

}

return 0;

ln++;

}

fclose(fp);

}

return 0;

}

fclose(fp);

return 0;

}

/*

* ����E���������̸�Ī���������E�˫ëȪ�����

*/

{

struct block_list *bl;

int i,c;

struct skill_unit *unit;

if (x < 0 || y < 0 || (x >= map[m].xs) || (y >= map[m].ys))

return NULL;

if (bl->x != x || bl->y != y || bl->type != BL_SKILL)

continue;

unit = (struct skill_unit *) bl;

return unit;

}

return NULL;

struct block_list * map_id2bl(int id)

{

struct block_list *bl=NULL;

bl = objects[id];

else

bl = (struct block_list*)numdb_search(id_db,id);

int map_getcellp(struct map_data* m,int x,int y,cell_t cellchk)

{

nullpo_ret(m);

if(x<0 || x>=m->xs-1 || y<0 || y>=m->ys-1)

if(cellchk==CELL_CHKNOPASS) return 1;

return 0;

}

switch(cellchk)

{

case CELL_CHKPASS:

case CELL_CHKNOPASS:

case CELL_CHKWALL:

case CELL_CHKWATER:

case CELL_CHKGROUND:

case CELL_GETTYPE:

default:

return 0;

}

return;

j=x+y*map[m].xs;

}

/*==========================================

mdos->gat = NULL;

mdos->ip = ip;

mdos->port = port;

strdb_insert(map_db,mdos->name,mdos);

} else {

}

mdos->ip = ip;

mdos->port = port;

}

return 0;

}

// ����������

/*==========================================

* ���ꍂ���ݒ�

fwrite(map_cache.map,map_cache.head.nmaps,sizeof(struct map_cache_info),map_cache.fp);

}

fclose(map_cache.fp);

map_cache.fp = NULL;

return;

}

if(fread(buf,1,size_compress,map_cache.fp) != size_compress) {

// �Ȃ����t�@�C���㔼�������Ă�̂œǂݒ���

printf("fread error\n");

return 0;

}

dest_len = m->xs * m->ys;

decode_zip(m->gat,&dest_len,buf,size_compress);

if(dest_len != map_cache.map[i].xs * map_cache.map[i].ys) {

// ����ɉ𓀂��o���ĂȂ�

return 0;

}

free(buf);

strdb_final(nick_db, nick_db_final);

numdb_final(charid_db, charid_db_final);

do_final_script();

do_final_itemdb();

do_final_storage();

#define MAX_STATUSCHANGE 210

#define MAX_SKILLUNITGROUP 32

#define MAX_MOBSKILLUNITGROUP 8

#define MAX_SKILLTIMERSKILL 32

#define MAX_MOBSKILLTIMERSKILL 10

#define MAX_MOBSKILL 32

int src_id;

int party_id;

int guild_id;

int target_flag;

unsigned int tick;

int limit,interval;

int skill_id,skill_lv;

char *valstr;

int unit_id;

int group_id;

unsigned char *gat; // NULL�Œ�ɂ��Ĕ��f

unsigned long ip;

unsigned int port;

};

struct flooritem_data {

LOOK_BASE,LOOK_HAIR,LOOK_WEAPON,LOOK_HEAD_BOTTOM,LOOK_HEAD_TOP,LOOK_HEAD_MID,LOOK_HAIR_COLOR,LOOK_CLOTHES_COLOR,LOOK_SHIELD,LOOK_SHOES

};

/*

*/

typedef enum {

} cell_t;

struct chat_data {

struct block_list bl;

int map_countnearpc(int,int,int);

//block�֘A�ɒlj�

int map_count_oncell(int m,int x,int y);

// �ꎞ�Iobject�֘A

int map_addobject(struct block_list *);

int map_delobject(int);

int map_mapname2ipport(char*,int*,int*);

int map_setipport(char *name,unsigned long ip,int port);

int map_eraseipport(char *name,unsigned long ip,int port);

void map_addiddb(struct block_list *);

void map_deliddb(struct block_list *bl);

int map_foreachiddb(int (*)(void*,void*,va_list),...);

dx = dirx[md->dir];

dy = diry[md->dir];

mob_walktoxy_sub(md);

return 0;

}

if (skill_check_basilica (&md->bl,x+dx,y+dy) ||

skill_check_moonlit (&md->bl,x+dx,y+dy)) {

mob_walktoxy_sub(md);

if(md->min_chase>13)

md->min_chase--;

if(moveblock) map_delblock(&md->bl);

md->bl.x = x;

md->bl.y = y;

if(moveblock) map_addblock(&md->bl);

map_foreachinmovearea(clif_mobinsight,md->bl.m,x-AREA_SIZE,y-AREA_SIZE,x+AREA_SIZE,y+AREA_SIZE,-dx,-dy,BL_PC,md);

md->state.state=MS_IDLE;

if(md->option&4)

skill_check_cloaking(&md->bl);

}

if((i=calc_next_walk_step(md))>0){

i = i>>1;

md->last_deadtime=gettick();

// Since it died, all aggressors' attack to this mob is stopped.

clif_foreachclient(mob_stopattacked,md->bl.id);

status_change_clear(&md->bl,2); // �X�e�[�^�X�ُ����������

skill_clear_unitgroup(&md->bl); // �S�ẴX�L�����j�b�g�O���[�v���폜����

skill_cleartimerskill(&md->bl);

static int mob_walktoxy_sub(struct mob_data *md)

{

struct walkpath_data wpd;

nullpo_retr(0, md);

if(path_search(&wpd,md->bl.m,md->bl.x,md->bl.y,md->to_x,md->to_y,md->state.walk_easy))

return 1;

memcpy(&md->walkpath,&wpd,sizeof(wpd));

md->state.change_walk_target=0;

md->last_spawntime=tick;

if( md->bl.prev!=NULL ){

// clif_clearchar_area(&md->bl,3);

map_delblock(&md->bl);

}

else

md->dir=0;

md->target_dir=0;

memset(&md->state,0,sizeof(md->state));

md->attacked_id = 0;

md->target_id = 0;

md->hp = status_get_max_hp(&md->bl);

}

clif_spawnmob(md);

return 0;

int mob_warp(struct mob_data *md,int m,int x,int y,int type)

{

int i=0,xs=0,ys=0,bx=x,by=y;

nullpo_retr(0, md);

return 0;

clif_clearchar_area(&md->bl,type);

}

map_delblock(&md->bl);

if(bx>0 && by>0){ // �ʒu�w��̏ꍇ���͂X�Z����T��

}

map_addblock(&md->bl);

if(type>0)

{

clif_spawnmob(md);

return 0;

}

if(battle_config.monster_land_skill_limit) {

maxcount = skill_get_maxcount(md->skillid);

else

weight = abs(y1 - y0);

if (map_getcellp(md,x0,y0,CELL_CHKWALL))

return 0;

wx += dx;

return 0;

}

sd->invincible_timer=-1;

return 0;

}

delete_timer(sd->invincible_timer,pc_invincible_timer);

sd->invincible_timer = -1;

}

return 0;

}

i = pc_search_inventory(sd,0);

if(i >= 0) {

memcpy(&sd->status.inventory[i],item_data,sizeof(sd->status.inventory[0]));

sd->inventory_data[i]=data;

clif_additem(sd,i,amount,0);

}

for(i=0;i<MAX_CART;i++){

if(sd->status.cart[i].nameid==0){

memcpy(&sd->status.cart[i],item_data,sizeof(sd->status.cart[0]));

sd->cart_num++;

clif_cart_additem(sd,i,amount,0);

break;

status_change_end(&sd->bl,SC_BLADESTOP,-1);

if(sd->sc_data[SC_DANCING].timer!=-1) // clear dance effect when warping [Valaris]

skill_stop_dancing(&sd->bl,0);

}

if(sd->status.option&2)

int ip,port;

if(map_mapname2ipport(mapname,&ip,&port)==0){

skill_stop_dancing(&sd->bl,1);

clif_clearchar_area(&sd->bl,clrtype&0xffff);

skill_gangsterparadise(sd,0);

map_delblock(&sd->bl);

}

if(sd->mapname[0] && sd->bl.prev != NULL){

clif_clearchar_area(&sd->bl,clrtype&0xffff);

skill_gangsterparadise(sd,0);

map_delblock(&sd->bl);

x += dx;

y += dy;

if(moveblock) map_delblock(&sd->bl);

sd->bl.x = x;

sd->bl.y = y;

if(moveblock) map_addblock(&sd->bl);

#if 0

if (sd->status.guild_id > 0) {

if (sd->sc_data[SC_DEVOTION].val1)

skill_devotion2(&sd->bl,sd->sc_data[SC_DEVOTION].val1);

}

}

if(map_getcell(sd->bl.m,x,y,CELL_CHKNPC))

npc_touch_areanpc(sd,sd->bl.m,x,y);

else

int pc_movepos(struct map_session_data *sd,int dst_x,int dst_y)

{

int moveblock;

struct walkpath_data wpd;

dx = dst_x - sd->bl.x;

dy = dst_y - sd->bl.y;

moveblock = ( sd->bl.x/BLOCK_SIZE != dst_x/BLOCK_SIZE || sd->bl.y/BLOCK_SIZE != dst_y/BLOCK_SIZE);

map_foreachinmovearea(clif_pcoutsight,sd->bl.m,sd->bl.x-AREA_SIZE,sd->bl.y-AREA_SIZE,sd->bl.x+AREA_SIZE,sd->bl.y+AREA_SIZE,dx,dy,0,sd);

if(moveblock) map_delblock(&sd->bl);

sd->bl.x = dst_x;

sd->bl.y = dst_y;

if(moveblock) map_addblock(&sd->bl);

map_foreachinmovearea(clif_pcinsight,sd->bl.m,sd->bl.x-AREA_SIZE,sd->bl.y-AREA_SIZE,sd->bl.x+AREA_SIZE,sd->bl.y+AREA_SIZE,-dx,-dy,0,sd);

if(sd->status.option&4) // �N��?�L���O�̏���?��

skill_check_cloaking(&sd->bl);

if(map_getcell(sd->bl.m,sd->bl.x,sd->bl.y,CELL_CHKNPC))

npc_touch_areanpc(sd,sd->bl.m,sd->bl.x,sd->bl.y);

else

return 0;

}

return 1;

if(sd->attacktimer != -1)

pc_stopattack(sd);

skill_castcancel(&sd->bl,0); // �r���̒��~

clif_clearchar_area(&sd->bl,1);

pc_setdead(sd);

if(sd->sc_data[SC_BLADESTOP].timer!=-1)//���n�͎��O�ɉ���

status_change_end(&sd->bl,SC_BLADESTOP,-1);

pc_setglobalreg(sd,"PC_DIE_COUNTER",++sd->die_counter); //���ɃJ�E���^?����?��

sd->status.status_point = val;

break;

case SP_ZENY:

break;

case SP_BASEEXP:

if(pc_nextbaseexp(sd) > 0) {

int pc_eventtimer(int tid,unsigned int tick,int id,int data)

{

struct map_session_data *sd=map_id2sd(id);

int i;

if(sd==NULL)

return 0;

for(i=0;i<MAX_EVENTTIMER;i++){

if( sd->eventtimer[i]==tid ){

sd->eventtimer[i]=-1;

break;

}

}

if(i==MAX_EVENTTIMER) {

if(battle_config.error_log)

printf("pc_eventtimer: no such event timer\n");

if( sd->eventtimer[i]==-1 )

break;

if(i<MAX_EVENTTIMER){

sd->eventtimer[i]=add_timer(gettick()+tick,

pc_eventtimer,sd->bl.id,(int)evname);

sd->eventcount++;

return 0;

for(i=0;i<MAX_EVENTTIMER;i++)

delete_timer(sd->eventtimer[i],pc_eventtimer);

sd->eventtimer[i]=-1;

sd->eventcount--;

break;

}

return 0;

for(i=0;i<MAX_EVENTTIMER;i++)

if( sd->eventtimer[i]!=-1 ){

delete_timer(sd->eventtimer[i],pc_eventtimer);

sd->eventtimer[i]=-1;

}

return 0;

int skill_get_castnodex( int id ,int lv ){ skill_get (skill_db[id].castnodex[lv-1], id, lv); }

int skill_get_delaynodex( int id ,int lv ){ skill_get (skill_db[id].delaynodex[lv-1], id, lv); }

int skill_get_nocast ( int id ){ skill_get (skill_db[id].nocast, id, 1); }

int skill_tree_get_max(int id, int b_class){

struct pc_base_job s_class = pc_calc_base_job(b_class);

int skill_landprotector(struct block_list *bl, va_list ap );

int skill_trap_splash(struct block_list *bl, va_list ap );

int skill_count_target(struct block_list *bl, va_list ap );

// [MouseJstr] - skill ok to cast? and when?

int skillnotok(int skillid, struct map_session_data *sd)

return dx>dy ? dx : dy;

}

{

}

/*==========================================

* �X�L���lj�?��

*------------------------------------------

nullpo_retr(0, target);

if(target->type==BL_PC){

}else if(target->type==BL_MOB){

}else if(target->type==BL_PET){

}else if(target->type==BL_SKILL){

}else return 0;

dx=target->x-src->x; dx=(dx>0)?1:((dx<0)?-1: 0);

dy=target->y-src->y; dy=(dy>0)?1:((dy<0)?-1: 0);

}

if(su){

skill_unit_move_unit_group(su->group,target->m,dx,dy);

}else{

}

if(sd) { /* ?��?�ɓ����Ă����̂ŕ\�� */

pd->state.state = prev_state;

}

return 0;

}

//����X�L���H�����܂�

switch(skillid){

case AS_SPLASHER:

clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, -1, 5);

break;

default:

clif_skill_damage(dsrc,bl,tick,dmg.amotion,dmg.dmotion, damage, dmg.div_, skillid, (lv!=0)?lv:skilllv, (skillid==0)? 5:type );

}

if(bl->type == BL_MOB)

clif_fixmobpos((struct mob_data *)bl);

else if(bl->type == BL_PET)

map_freeblock_lock();

/* ?�ۂɃ_��?�W?�����s�� */

if(skillid == RG_INTIMIDATE && damage > 0 && !(status_get_mode(bl)&0x20) && !map[src->m].flag.gvg ) {

int s_lv = status_get_lv(src),t_lv = status_get_lv(bl);

int rate = 50 + skilllv * 5;

battle_heal(NULL,bl,0,-sp,0);

}

if(attack_type&BF_WEAPON && sc_data && sc_data[SC_AUTOCOUNTER].timer != -1 && sc_data[SC_AUTOCOUNTER].val4 > 0) {

if(sc_data[SC_AUTOCOUNTER].val3 == dsrc->id)

static int skill_check_unit_range_sub( struct block_list *bl,va_list ap )

{

struct skill_unit *unit;

nullpo_retr(0, bl);

nullpo_retr(0, ap);

if(!unit->alive)

return 0;

skillid = va_arg(ap,int);

return 0;

return 0;

return 0;

return 0;

return 0;

}

{

int c = 0;

return c;

}

static int skill_check_unit_range2_sub( struct block_list *bl,va_list ap )

{

int *c;

nullpo_retr(0, bl);

nullpo_retr(0, ap);

if(bl->type == BL_PC && pc_isdead((struct map_session_data *)bl))

return 0;

(*c)++;

return 0;

}

{

int c = 0;

return c;

}

return 0;

}

/*==========================================

*

*------------------------------------------

src->x+range,src->y+range,0,src,skl->skill_id,skl->skill_lv,tick);

break;

default:

skill_attack(skl->type,src,src,target,skl->skill_id,skl->skill_lv,tick,skl->flag);

break;

if(sd && pc_isdead(sd))

return 1;

bl = src;

if(bl->prev == NULL)

return 1;

case WZ_WATERBALL: /* �E�H?�^?�{?�� */

skill_attack(BF_MAGIC,src,src,bl,skillid,skilllv,tick,flag);

break;

case PR_BENEDICTIO: /* ��?�~�� */

/* ���@�n��?�U?�X�L�� */

case MG_NAPALMBEAT: /* �i�p?���r?�g */

case MG_FIREBALL: /* �t�@�C��?�{?�� */

if(flag&1){

/* �•ʂɃ_��?�W��?���� */

if(bl->id!=skill_area_temp[1]){

skill_area_temp[0]| 0x0500);

}

}else{

skill_area_temp[1]=bl->id;

}

map_foreachinarea(skill_area_sub,

}

break;

map_foreachinarea(skill_attack_area,src->m,src->x-5,bl->y-5,bl->x+5,bl->y+5,0,BF_MAGIC,src,src,skillid,skilllv,tick,flag,BCT_ENEMY);

break;

/* ���̑� */

case HT_BLITZBEAT: /* �u���b�c�r?�g */

if(flag&1){

nullpo_retr(0, sd=(struct map_session_data *)src);

}

if( skillid != WZ_METEOR &&

skillid != AM_CANNIBALIZE &&

skillid != AM_SPHEREMINE)

clif_skill_poseffect(src,skillid,skilllv,x,y,tick);

case AL_PNEUMA: /* �j��?�} */

case WZ_ICEWALL: /* �A�C�X�E�H?�� */

case WZ_FIREPILLAR: /* �t�@�C�A�s��? */

case WZ_QUAGMIRE: /* �N�@�O�}�C�A */

case WZ_VERMILION: /* ��?�h�I�u���@?�~���I�� */

//case WZ_FROSTNOVA: /* �t���X�g�m���@ */

struct skill_unit_group *skill_unitsetting( struct block_list *src, int skillid,int skilllv,int x,int y,int flag)

{

struct skill_unit_group *group;

struct status_change *sc_data;

nullpo_retr(0, src);

sc_data = status_get_sc_data(src); // for firewall and fogwall - celest

switch(skillid){ /* �ݒ� */

case MG_SAFETYWALL: /* �Z�C�t�e�B�E�H?�� */

val2=skilllv+1;

break;

case MG_FIREWALL: /* �t�@�C��?�E�H?�� */

val2=4+skilllv;

break;

case AL_WARP: /* ��?�v�|?�^�� */

val1=skilllv+6;

if(flag==0)

limit=2000;

break;

case PR_SANCTUARY: /* �T���N�`���A�� */

val1=(skilllv+3)*2;

val2=(skilllv>6)?777:skilllv*100;

break;

case WZ_FIREPILLAR: /* �t�@�C�A?�s��? */

limit=1000;

val1=skilllv+2;

range=2;

break;

case HT_SANDMAN: /* �T���h�}�� */

case HT_CLAYMORETRAP: /* �N���C���A?�g���b�v */

case HT_SKIDTRAP: /* �X�L�b�h�g���b�v */

case HT_LANDMINE: /* �����h�}�C�� */

case HT_ANKLESNARE: /* �A���N���X�l�A */

case HT_FLASHER: /* �t���b�V��? */

case HT_FREEZINGTRAP: /* �t��?�W���O�g���b�v */

case HT_BLASTMINE: /* �u���X�g�}�C�� */

// longer trap times in WOE [celest]

break;

case HT_SHOCKWAVE: /* �V���b�N�E�F?�u�g���b�v */

val1=skilllv*15+10;

break;

case SA_LANDPROTECTOR: /* �O�����h�N���X */

break;

case BA_WHISTLE: /* ���J */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,BA_MUSICALLESSON)+1)>>1;

val2 = ((status_get_agi(src)/10)&0xffff)<<16;

val2 |= (status_get_luk(src)/10)&0xffff;

break;

case DC_HUMMING: /* �n�~���O */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,DC_DANCINGLESSON)+1)>>1;

val2 = status_get_dex(src)/10;

break;

case DC_DONTFORGETME: /* ����Y��Ȃ��Łc */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,DC_DANCINGLESSON)+1)>>1;

val2 = ((status_get_str(src)/20)&0xffff)<<16;

val2 |= (status_get_agi(src)/10)&0xffff;

break;

case BA_POEMBRAGI: /* �u���M�̎� */

if(src->type == BL_PC)

val1 = pc_checkskill((struct map_session_data *)src,BA_MUSICALLESSON);

val2 = ((status_get_dex(src)/10)&0xffff)<<16;

val2 |= (status_get_int(src)/5)&0xffff;

break;

case BA_APPLEIDUN: /* �C�h�D���̗ь� */

if(src->type == BL_PC)

val1 = ((pc_checkskill((struct map_session_data *)src,BA_MUSICALLESSON))&0xffff)<<16;

break;

case DC_SERVICEFORYOU: /* �T?�r�X�t�H?��? */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,DC_DANCINGLESSON)+1)>>1;

val2 = status_get_int(src)/10;

break;

case BA_ASSASSINCROSS: /* �[�z�̃A�T�V���N���X */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,BA_MUSICALLESSON)+1)>>1;

val2 = status_get_agi(src)/20;

break;

case DC_FORTUNEKISS: /* �K�^�̃L�X */

if(src->type == BL_PC)

val1 = (pc_checkskill((struct map_session_data *)src,DC_DANCINGLESSON)+1)>>1;

val2 = status_get_luk(src)/10;

break;

case HP_BASILICA: /* �o�W���J */

//Fix to prevent the priest from walking while Basilica is up.

battle_stopwalking(src,1);

break;

case PF_FOGWALL: /* �t�H�O�E�H?�� */

break;

case RG_GRAFFITI: /* Graffiti */

count=1; // Leave this at 1 [Valaris]

break;

case GD_LEADERSHIP:

target=BCT_ALL;

limit=300000;

break;

}

group->limit=limit;

group->val1=val1;

group->val2=val2;

group->target_flag=target;

group->interval=interval;

if(skillid==HT_TALKIEBOX ||

skillid==RG_GRAFFITI){

group->valstr=aCallocA(80, 1);

}

memcpy(group->valstr,talkie_mes,80);

}

struct skill_unit *unit;

case MG_FIREWALL: /* �t�@�C��?�E�H?�� */

break;

case WZ_ICEWALL: /* �A�C�X�E�H?�� */

if(skilllv <= 1)

val1 = 500;

else

val1 = 200 + 200*skilllv;

break;

case RG_GRAFFITI: /* Graffiti [Valaris] */

ux+=(i%5-2);

unit->val2=val2;

unit->limit=limit;

unit->range=range;

// [celest]

if (sc_data) {

// attach the unit's id to the caster

break;

}

}

}

}

return group;

{

struct skill_unit_group *sg;

struct block_list *ss;

struct status_change *sc_data;

nullpo_retr(0, src);

nullpo_retr(0, bl);

return 0;

nullpo_retr(0, sg=src->group);

nullpo_retr(0, ss=map_id2bl(sg->src_id));

return 0;

return 0;

break;

}

break;

}

break;

{

}

}

break;

}

break;

break;

skill_delunit(src);

break;

skill_delunit(src);

skill_unitsetting(ss,sg->skill_id,sg->skill_lv,src->bl.x,src->bl.y,1);

break;

break;

case 0x90: /* �X�L�b�h�g���b�v */

clif_changelook(&src->bl,LOOK_BASE,sg->unit_id);

sg->limit=DIFF_TICK(tick,sg->tick)+1500;

}

case 0x93: /* �����h�}�C�� */

skill_attack(BF_MISC,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);

break;

case 0x91: /* �A���N���X�l�A */

if(moveblock) map_delblock(bl);

bl->x = src->bl.x;

bl->y = src->bl.y;

if(moveblock) map_addblock(bl);

if(bl->type == BL_MOB)

clif_fixmobpos((struct mob_data *)bl);

else if(bl->type == BL_PET)

else

clif_fixpos(bl);

clif_01ac(&src->bl);

sg->val2=bl->id;

}

break;

case 0x92: /* �x�m���_�X�g */

break;

case 0xb1: /* �f�����X�g��?�V���� */

skill_attack(BF_WEAPON,ss,&src->bl,bl,sg->skill_id,sg->skill_lv,tick,0);

if(bl->type == BL_PC && rand()%100 < sg->skill_lv && battle_config.equipment_breaking)

pc_breakweapon((struct map_session_data *)bl);

break;

break;

if(sg->val2==0){

clif_talkiebox(&src->bl,sg->valstr);

sg->limit=DIFF_TICK(tick,sg->tick)+5000;

sg->val2=-1; //����

}

case 0xb7: /* �X�p�C�_?�E�F�b�u */

if(sg->val2==0){

int moveblock = ( bl->x/BLOCK_SIZE != src->bl.x/BLOCK_SIZE || bl->y/BLOCK_SIZE != src->bl.y/BLOCK_SIZE);

skill_additional_effect(ss,bl,sg->skill_id,sg->skill_lv,BF_MISC,tick);

if(moveblock) map_delblock(bl);

if(moveblock) map_addblock(bl);

sg->val2=bl->id;

}

break;

printf("skill_unit_onplace: Unknown skill unit id=%d block=%d\n",sg->unit_id,bl->id);

break;*/

}

if(bl->type==BL_MOB && ss!=bl) /* �X�L���g�p?����MOB�X�L�� */

{

if(battle_config.mob_changetarget_byskill == 1)

int skill_unit_onout(struct skill_unit *src,struct block_list *bl,unsigned int tick)

{

struct skill_unit_group *sg;

nullpo_retr(0, src);

nullpo_retr(0, bl);

nullpo_retr(0, sg=src->group);

return 0;

switch(sg->unit_id){

case 0x8e: /* �N�@�O�}�C�A */

}

break;

sg->limit=DIFF_TICK(tick,sg->tick)+1000;

}

break;

case 0x9e: /* �q��S */

case 0x9f: /* �j�����h�̉� */

case 0xa0: /* �i���̍��� */

case 0xae: /* �K�^�̃L�X */

case 0xaf: /* �T?�r�X�t�H?��? */

case 0xb4:

}

break;

case 0xb7: /* �X�p�C�_?�E�F�b�u */

{

status_change_end(bl,SC_SPIDERWEB,-1);

}

case 0xc1: // GD_LEADERSHIP

{

struct map_session_data *sd;

sd->state.hawkeyes_flag = 0;

}

break;

/* default:

if(battle_config.error_log)

printf("skill_unit_onout: Unknown skill unit id=%d block=%d\n",sg->unit_id,bl->id);

break;*/

}

return 0;

}

/*==========================================

*------------------------------------------

*/

{

nullpo_retr(0, bl);

return 0;

return 0;

}

return 0;

}

/*==========================================

* �X�L�����j�b�g�̌��E�C�x���g

*------------------------------------------

return 0;

}

case WZ_FIREPILLAR:

case HT_SKIDTRAP:

case HT_LANDMINE:

case HT_CLAYMORETRAP:

case HT_TALKIEBOX:

case AL_WARP:

range = 0;

break;

case AL_PNEUMA:

range = 1;

}

case HT_SKIDTRAP:

case HT_LANDMINE:

case HT_ANKLESNARE:

case HT_BLASTMINE:

case HT_CLAYMORETRAP:

case HT_TALKIEBOX:

case WZ_ICEWALL:

range = 2;

break;

case AL_WARP:

range = 0;

}

if(battle_config.pc_land_skill_limit) {

maxcount = skill_get_maxcount(sd->skillid);

if(maxcount > 0) {

return 0;

}

break;

case PF_MEMORIZE: /* �������C�Y */

casttime = 12000;

break;

case HW_MAGICPOWER:

casttime = 700;

break;

case GD_BATTLEORDER:

case GD_REGENERATION:

case GD_RESTORE:

int n,r=0;

nullpo_retr(1, bl);

return 1;

else

r = distance(bl->x,bl->y,sd->bl.x,sd->bl.y);

for(n=0;n<5;n++)

if(md->dev.val1[n]==target)

md->dev.val2[n]=0; // ���ꂽ���́A?��؂邾��

//NPC�X�L���̓_��

if(skill >= NPC_PIERCINGATT && skill <= NPC_SUMMONMONSTER) return 0;

//���t�X�L���̓_��

return skill;

}

/*==========================================

*

*------------------------------------------

*/

{

struct mob_data *md=NULL;

struct map_session_data *sd=NULL;

nullpo_retr(0, bl);

if(sd){

skillid=sd->skillunit[i].skill_id;

if(skillid==SA_DELUGE||skillid==SA_VOLCANO||skillid==SA_VIOLENTGALE||skillid==SA_LANDPROTECTOR)

* �w���??��src��?���ėL?�ȃ^?�Q�b�g��bl��?��?����(foreachinarea)

*------------------------------------------

*/

struct block_list *src;

int *c;

*/

/*==========================================

* ���t/�_���X����߂�

* flag 1�ō��t���Ȃ瑊���Ƀ��j�b�g��C����

*

map_addblock(&unit->bl);

clif_skill_setunit(unit);

return unit;

}

/*==========================================

* �X�L�����j�b�g�폜

*------------------------------------------

int skill_delunit(struct skill_unit *unit)

{

struct skill_unit_group *group;

nullpo_retr(0, unit);

if(!unit->alive)

/* onlimit�C�x���g�Ăяo�� */

skill_unit_onlimit( unit,gettick() );

clif_skill_delunit(unit);

* �X�L�����j�b�g�O��?�v������

*------------------------------------------

*/

struct skill_unit_group *skill_initunitgroup(struct block_list *src,

int count,int skillid,int skilllv,int unit_id)

{

group->guild_id=status_get_guild_id(src);

group->group_id=skill_unit_group_newid++;

if(skill_unit_group_newid<=0)

group->unit=(struct skill_unit *)aCalloc(count,sizeof(struct skill_unit));

group->unit_count=count;

group->val1=group->val2=0;

group->skill_lv=skilllv;

group->unit_id=unit_id;

group->map=src->m;

group->limit=10000;

group->interval=1000;

group->tick=gettick();

group->valstr=NULL;

struct map_session_data *sd = NULL;

if(src->type==BL_PC && (sd=(struct map_session_data *)src) ){

sd->skillid_dance=skillid;

sd->skilllv_dance=skilllv;

}

status_change_start(src,SC_DANCING,skillid,(int)group,0,0,skill_get_time(skillid,skilllv)+1000,0);

}

}

return group;

return 0;

src=map_id2bl(group->src_id);

if(src)

status_change_end(src,SC_DANCING,-1);

}

if(src->type==BL_PC){

group=((struct map_session_data *)src)->skillunit;

maxsug=MAX_SKILLUNITGROUP;

group=((struct mob_data *)src)->skillunit;

maxsug=MAX_MOBSKILLUNITGROUP;

group=((struct pet_data *)src)->skillunit;

maxsug=MAX_MOBSKILLUNITGROUP;

if(group){

int i;

for(i=0;i<maxsug;i++)

return 0;

}

/*==========================================

* �X�L�����j�b�g�O��?�v�̔�e��tick?��

*------------------------------------------

*/

struct skill_unit_group_tickset *skill_unitgrouptickset_search(

{

int i,j=-1,k,s,id;

struct skill_unit_group_tickset *set;

nullpo_retr(0, bl);

if (bl->type == BL_PC)

set = ((struct map_session_data *)bl)->skillunittick;

else

return 0;

else

for (i=0; i<MAX_SKILLUNITGROUPTICKSET; i++) {

k = (i+s) % MAX_SKILLUNITGROUPTICKSET;

if (set[k].id == id)

return &set[k];

j=k;

}

sprintf (tmp_output, "skill_unitgrouptickset_search: tickset is full\n");

ShowWarning (tmp_output);

}

j = id % MAX_SKILLUNITGROUPTICKSET;

}

set[j].id = id;

return &set[j];

}

/*==========================================

* �X�L�����j�b�g�^�C�}??��?���p(foreachinarea)

*------------------------------------------

*/

int skill_unit_timer_sub_onplace( struct block_list *bl, va_list ap )

{

unsigned int tick;

nullpo_retr(0, bl);

nullpo_retr(0, ap);

return 0;

}

nullpo_retr(0, bl);

nullpo_retr(0, ap);

nullpo_retr(0, unit=(struct skill_unit *)bl);

tick=va_arg(ap,unsigned int);

if(!unit->alive)

return 0;

}

}

/* ���Ԑ؂�폜 */

switch(group->unit_id){

case 0x8f: /* �u���X�g�}�C�� */

group->unit_id = 0x8c;

* �X�L�����j�b�g�ړ���?���p(foreachinarea)

*------------------------------------------

*/

int skill_unit_move_sub( struct block_list *bl, va_list ap )

{

struct skill_unit_group *group;

nullpo_retr(0, bl);

nullpo_retr(0, ap);

return 0;

return 0;

return 0;

else

return 0;

}

* �X�L�����j�b�g�ړ���?��

*------------------------------------------

*/

{

nullpo_retr(0, bl);

return 0;

return 0;

}

*/

int skill_unit_move_unit_group( struct skill_unit_group *group, int m,int dx,int dy)

{

nullpo_retr(0, group);

return 0;

}

}

}

}

}

return 0;

}

if(!equip) {

// Corrected rates [DracoRPG] --------------------------//

if(skill_produce_db[idx].req_skill==AM_PHARMACY) {

if(nameid >= 501 && nameid <= 505) // Normal potions

else if(nameid >= 545 && nameid <= 547) // Concentrated potions

else if(nameid == 970) // Alcohol

else if(nameid == 7135) // Bottle Grenade

else if(nameid == 7136) // Acid Bottle

else if(nameid == 7137) // Plant Bottle

else if(nameid == 7138) // Marine Sphere Bottle

else if(nameid == 7139) // Glistening Coat

else

make_per = 1000 + sd->status.base_level*30 + sd->paramc[3]*20 + sd->paramc[4]*15 + pc_checkskill(sd,AM_LEARNINGPOTION)*100 + pc_checkskill(sd,AM_PHARMACY)*300;

} else if (skill_produce_db[idx].req_skill == ASC_CDP) {

clif_additem(sd,0,0,flag);

map_addflooritem(&tmp_item,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);

}

if(log_config.produce > 0)

log_produce(sd,nameid,slot1,slot2,slot3,0);

* �������n

*/

/*==========================================

* �X�L��?�W�t�@�C��?��?��

* skill_db.txt �X�L���f?�^

return 1;

}

while(fgets(line,1020,fp)){

if(line[0]=='/' && line[1]=='/')

continue;

if(split[13]==NULL || j<14)

continue;

continue;

/* printf("skill id=%d\n",i); */

skill_db[i].hit=atoi(split[2]);

skill_db[i].inf=atoi(split[3]);

skill_db[i].pl=atoi(split[4]);

skill_db[i].nk=atoi(split[5]);

skill_db[i].max=atoi(split[6]);

if(strcmpi(split[8],"yes") == 0)

skill_db[i].castcancel=1;

skill_db[i].skill_type=BF_MISC;

else

skill_db[i].skill_type=0;

}

fclose(fp);

sprintf(tmp_output,"Done reading '"CL_WHITE"%s"CL_RESET"'.\n","db/skill_db.txt");

return 1;

}

while(fgets(line,1020,fp)){

if(line[0]=='/' && line[1]=='/')

continue;

if(split[29]==NULL || j<30)

continue;

else if(i<=0 || i>MAX_SKILL_DB)

continue;

skill_db[i].weapon = 0xffffffff;

break;

}

else

skill_db[i].weapon |= 1<<l;

}

if( strcmpi(split[8],"hiding")==0 ) skill_db[i].state=ST_HIDING;

else if( strcmpi(split[8],"water")==0 ) skill_db[i].state=ST_WATER;

else skill_db[i].state=ST_NONE;

skill_db[i].itemid[0]=atoi(split[10]);

skill_db[i].amount[0]=atoi(split[11]);

skill_db[i].itemid[1]=atoi(split[12]);

return 1;

}

while(fgets(line,1020,fp)){

memset(split,0,sizeof(split)); // [Valaris] thanks to fov

if(line[0]=='/' && line[1]=='/')

continue;

if(split[4]==NULL || j<5)

continue;

else if(i<=0 || i>MAX_SKILL_DB)

continue;

}

fclose(fp);

ShowStatus(tmp_output);

/* �����n�X�L���f?�^�x?�X */

memset(skill_produce_db,0,sizeof(skill_produce_db));

if(line[0]=='/' && line[1]=='/')

continue;

memset(split,0,sizeof(split));

if(split[0]==0) //fixed by Lupus

continue;

i=atoi(split[0]);

skill_produce_db[k].nameid=i;

skill_produce_db[k].itemlv=atoi(split[1]);

if(line[0]=='/' && line[1]=='/')

continue;

memset(split,0,sizeof(split));

if(split[0]==0) //fixed by Lupus

continue;

i=atoi(split[0]);

if(line[0]=='/' && line[1]=='/')

continue;

memset(split,0,sizeof(split));

if(split[0]==0) //fixed by Lupus

continue;

i=atoi(split[0]);

return 1;

}

while(fgets(line,1020,fp)){

if(line[0]=='/' && line[1]=='/')

continue;

memset(split,0,sizeof(split));

if(split[0]==0) //fixed by Lupus

continue;

i=atoi(split[0]);

else if(i<=0 || i>MAX_SKILL_DB)

continue;

if (!split[2])

continue;

}

fclose(fp);

sprintf(tmp_output,"Done reading '"CL_WHITE"%s"CL_RESET"'.\n","db/skill_castnodex_db.txt");

if(line[0]=='/' && line[1]=='/')

continue;

memset(split,0,sizeof(split));

if(split[0]==0) //fixed by Lupus

continue;

i=atoi(split[0]);

int castnodex[MAX_SKILL_LEVEL];

int delaynodex[MAX_SKILL_LEVEL];

int nocast;

};

extern struct skill_db skill_db[MAX_SKILL_DB];

};

extern const struct skill_name_db skill_names[];

// �A�C�e���쐬�f?�^�x?�X

struct skill_produce_db {

int nameid, trigger;

int skill_get_inf2( int id );

int skill_get_maxcount( int id );

int skill_get_blewcount( int id ,int lv );

int skill_tree_get_max( int id, int b_class ); // Celest

// �X�L���̎g�p

struct skill_unit_group *skill_initunitgroup(struct block_list *src,

int count,int skillid,int skilllv,int unit_id);

int skill_delunitgroup(struct skill_unit_group *group);

int skill_clear_unitgroup(struct block_list *src);

int skill_unit_ondamaged(struct skill_unit *src,struct block_list *bl,

int skill_castfix( struct block_list *bl, int time );

int skill_delayfix( struct block_list *bl, int time );

// -- moonsoul (added skill_check_unit_cell)

int skill_check_unit_cell(int skillid,int m,int x,int y,int unit_id);

int skill_unit_out_all( struct block_list *bl,unsigned int tick,int range);

int skill_unit_move_unit_group( struct skill_unit_group *group, int m,int dx,int dy);

struct skill_unit_group *skill_check_dancing( struct block_list *src );

// ���̑�

int skill_check_cloaking(struct block_list *bl);

int skill_type_cloaking(struct block_list *bl);

// �X�e?�^�X�ُ�

int skill_encchant_eremental_end(struct block_list *bl, int type);

-1, 1,-1,

/* 10- */

SC_SIGHT, /* �T�C�g */

SC_FREEZE, /* �t���X�g�_�C�o? */

SC_STONE, /* �X�g?���J?�X */

-1,-1,-1,

/* 20- */

-1,-1,-1,-1,

SC_RUWACH, /* ���A�t */

SC_INCREASEAGI, /* ���x?�� */

/* 30- */

SC_DECREASEAGI, /* ���x���� */

case SC_ANKLE:

break;

/* �X�L������Ȃ�/���Ԃ�?�W���Ȃ� */

case SC_RIDING:

calc_flag = 1;

}

break;

case SC_ENDURE: /* �C���f���A */

case SC_AUTOBERSERK: // Celest

if(sd && sd->special_state.infinite_endure) {

//-- 137-139

SC_SAFETYWALL = 140,

SC_PNEUMA = 141,

SC_ANKLE = 143,

SC_DANCING = 144,

SC_KEEPING = 145,

all: char-converter

sql: char-converter

char-converter: char-converter.o $(COMMON_OBJ)

$(CC) -o ../../../$@ $^ $(LIB_S)

all: login-converter

sql: login-converter

COMMON_H = ../../common/core.h ../../common/socket.h ../../common/timer.h ../../common/mmo.h ../../common/version.h ../../common/db.h ../../common/malloc.h ../../common/strlib.h