g[0]=guild_search(sd->status.guild_id);
	g[1]=guild_search(tsd->status.guild_id);
	
	if(g[0]==NULL || g[1]==NULL)
		return 0;
	
	if( guild_get_alliance_count(g[0],0)>3 )	// 摨柨悢妋擣
		clif_guild_allianceack(sd,4);
	if( guild_get_alliance_count(g[1],0)>3 )
		clif_guild_allianceack(sd,3);
	
	if( tsd->guild_alliance>0 ){	// 憡庤偑摨柨梫惪忬懺偐偳偆偐妋擣
		clif_guild_allianceack(sd,1);
		return 0;
	}

	for(i=0;i<MAX_GUILDALLIANCE;i++){	// 偡偱偵摨柨忬懺偐妋擣
		if(	g[0]->alliance[i].guild_id==tsd->status.guild_id &&
			g[0]->alliance[i].opposition==0){
			clif_guild_allianceack(sd,0);
			return 0;
		}
	}
	
	tsd->guild_alliance=sd->status.guild_id;
	tsd->guild_alliance_account=sd->status.account_id;

	clif_guild_reqalliance(tsd,sd->status.account_id,g[0]->name);
	return 0;
}
// 僊儖僪姪桿傊偺曉摎
int guild_reply_reqalliance(struct map_session_data *sd,int account_id,int flag)
{
	struct map_session_data *tsd= map_id2sd( account_id );

	if(sd->guild_alliance!=tsd->status.guild_id)	// 姪桿偲僊儖僪ID偑堘偆
		return 0;

	if(flag==1){	// 彸戻
		int i;
		
		struct guild *g;	// 摨柨悢嵞妋擣
		if( (g=guild_search(sd->status.guild_id))==NULL ||
			guild_get_alliance_count(g,0)>3 ){
			clif_guild_allianceack(sd,4);
			clif_guild_allianceack(tsd,3);
			return 0;
		}
		if( (g=guild_search(tsd->status.guild_id))==NULL ||
			guild_get_alliance_count(g,0)>3 ){
			clif_guild_allianceack(sd,3);
			clif_guild_allianceack(tsd,4);
			return 0;
		}
		
		// 揋懳娭學(xué)側(cè)傜揋懳傪巭傔傞
		g=guild_search(sd->status.guild_id);
		for(i=0;i<MAX_GUILDALLIANCE;i++){
			if(	g->alliance[i].guild_id==tsd->status.guild_id &&
				g->alliance[i].opposition==1)
				intif_guild_alliance( sd->status.guild_id,tsd->status.guild_id,
					sd->status.account_id,tsd->status.account_id,9 );
		}
		g=guild_search(tsd->status.guild_id);
		for(i=0;i<MAX_GUILDALLIANCE;i++){
			if(	g->alliance[i].guild_id==sd->status.guild_id &&
				g->alliance[i].opposition==1)
				intif_guild_alliance( tsd->status.guild_id,sd->status.guild_id,
					tsd->status.account_id,sd->status.account_id,9 );
		}

		// inter嶪傊摨柨梫惪
		intif_guild_alliance( sd->status.guild_id,tsd->status.guild_id,
			sd->status.account_id,tsd->status.account_id,0 );
		return 0;
	}else{		// 嫅斲
		sd->guild_alliance=0;
		sd->guild_alliance_account=0;
		if(tsd!=NULL)
			clif_guild_allianceack(tsd,3);
	}
	return 0;
}
// 僊儖僪娭學(xué)夝徚
int guild_delalliance(struct map_session_data *sd,int guild_id,int flag)
{
	intif_guild_alliance( sd->status.guild_id,guild_id,
		sd->status.account_id,0,flag|8 );
	return 0;
}
// 僊儖僪揋懳
int guild_opposition(struct map_session_data *sd,int char_id)
{
	struct map_session_data *tsd=map_id2sd(char_id);
	struct guild *g=guild_search(sd->status.guild_id);
	int i;
	
	if(g==NULL || tsd==NULL)
		return 0;	
	
	if( guild_get_alliance_count(g,1)>3 )	// 揋懳悢妋擣
		clif_guild_oppositionack(sd,1);
	
	for(i=0;i<MAX_GUILDALLIANCE;i++){	// 偡偱偵娭學(xué)傪帩偭偰偄傞偐妋擣
		if(g->alliance[i].guild_id==tsd->status.guild_id){
			if(g->alliance[i].opposition==1){	// 偡偱偵揋懳
				clif_guild_oppositionack(sd,2);
				return 0;
			}else	// 摨柨攋婞
				intif_guild_alliance( sd->status.guild_id,tsd->status.guild_id,
					sd->status.account_id,tsd->status.account_id,8 );
		}
	}

	// inter嶪偵揋懳梫惪
	intif_guild_alliance( sd->status.guild_id,tsd->status.guild_id,
			sd->status.account_id,tsd->status.account_id,1 );
	return 0;
}
// 僊儖僪摨柨/揋懳捠抦
int guild_allianceack(int guild_id1,int guild_id2,int account_id1,int account_id2,
	int flag,const char *name1,const char *name2)
{
	struct guild *g[2];
	int guild_id[2]={guild_id1,guild_id2};
	const char *guild_name[2]={name1,name2};
	struct map_session_data *sd[2]={map_id2sd(account_id1),map_id2sd(account_id2)};
	int j,i;
	
	g[0]=guild_search(guild_id1);
	g[1]=guild_search(guild_id2);
	
	if(sd[0]!=NULL && (flag&0x0f)==0){
		sd[0]->guild_alliance=0;
		sd[0]->guild_alliance_account=0;
	}
	
	if(flag&0x70){	// 幐攕
		for(i=0;i<2-(flag&1);i++)
			if( sd[i]!=NULL )
				clif_guild_allianceack(sd[i],((flag>>4)==i+1)?3:4);
		return 0;
	}
//	if(battle_config.etc_log)
//		printf("guild alliance_ack %d %d %d %d %d %s %s\n",guild_id1,guild_id2,account_id1,account_id2,flag,name1,name2);

	if(!(flag&0x08)){	// 娭學(xué)捛壛
		for(i=0;i<2-(flag&1);i++)
			if(g[i]!=NULL)
				for(j=0;j<MAX_GUILDALLIANCE;j++)
					if(g[i]->alliance[j].guild_id==0){
						g[i]->alliance[j].guild_id=guild_id[1-i];
						memcpy(g[i]->alliance[j].name,guild_name[1-i],24);
						g[i]->alliance[j].opposition=flag&1;
						break;
					}
	}else{				// 娭學(xué)夝徚
		for(i=0;i<2-(flag&1);i++){
			if(g[i]!=NULL)
				for(j=0;j<MAX_GUILDALLIANCE;j++)
					if(	g[i]->alliance[j].guild_id==guild_id[1-i] &&
						g[i]->alliance[j].opposition==(flag&1)){
						g[i]->alliance[j].guild_id=0;
						break;
					}
			if( sd[i]!=NULL )	// 夝徚捠抦
				clif_guild_delalliance(sd[i],guild_id[1-i],(flag&1));
		}
	}
	
	if((flag&0x0f)==0){			// 摨柨捠抦
		if( sd[1]!=NULL )
			clif_guild_allianceack(sd[1],2);
	}else if((flag&0x0f)==1){	// 揋懳捠抦
		if( sd[0]!=NULL )
			clif_guild_oppositionack(sd[0],0);
	}


	for(i=0;i<2-(flag&1);i++){	// 摨柨/揋懳儕僗僩偺嵞憲怣
		struct map_session_data *sd;
		if(g[i]!=NULL)
			for(j=0;j<g[i]->max_member;j++)
				if((sd=g[i]->member[j].sd)!=NULL)
					clif_guild_allianceinfo(sd);
	}
	return 0;
}
// 僊儖僪夝嶶捠抦梡
int guild_broken_sub(void *key,void *data,va_list ap)
{
	struct guild *g=(struct guild *)data;
	int guild_id=va_arg(ap,int);
	int i,j;
	struct map_session_data *sd=NULL;
	
	for(i=0;i<MAX_GUILDALLIANCE;i++){	// 娭學(xué)傪攋婞
		if(g->alliance[i].guild_id==guild_id){
			for(j=0;j<g->max_member;j++)
				if( (sd=g->member[j].sd)!=NULL )
					clif_guild_delalliance(sd,guild_id,g->alliance[i].opposition);
			g->alliance[i].guild_id=0;
		}
	}
	return 0;
}
// 僊儖僪夝嶶捠抦
int guild_broken(int guild_id,int flag)
{
	struct guild *g=guild_search(guild_id);
	struct map_session_data *sd;
	int i;
	if(flag!=0 || g==NULL)
		return 0;
	
	for(i=0;i<g->max_member;i++){	// 僊儖僪夝嶶傪捠抦
		if((sd=g->member[i].sd)!=NULL){
			if(sd->state.storage_flag)
				storage_guild_storage_quit(sd,1);
			sd->status.guild_id=0;
			sd->guild_sended=0;
			clif_guild_broken(g->member[i].sd,0);
		}
	}

	numdb_foreach(guild_db,guild_broken_sub,guild_id);
	numdb_erase(guild_db,guild_id);
	guild_storage_delete(guild_id);
	free(g);
	return 0;
}

// 僊儖僪夝嶶
int guild_break(struct map_session_data *sd,char *name)
{
	struct guild *g;
	int i;
	if( (g=guild_search(sd->status.guild_id))==NULL )
		return 0;
	if(strcmp(g->name,name)!=0)
		return 0;
	if(strcmp(sd->status.name,g->master)!=0)
		return 0;
	for(i=0;i<g->max_member;i++){
		if(	g->member[i].account_id>0 && (
			g->member[i].account_id!=sd->status.account_id ||
			g->member[i].char_id!=sd->status.char_id ))
			break;
	}
	if(i<g->max_member){
		clif_guild_broken(sd,2);
		return 0;
	}
	
	intif_guild_break(g->guild_id);
	return 0;
}

// 僊儖僪忛僨乕僞梫媮
int guild_castledataload(int castle_id,int index)
{
	return intif_guild_castle_dataload(castle_id,index);
}
// 僊儖僪忛忣曬強(qiáng)摼帪僀儀儞僩捛壛
int guild_addcastleinfoevent(int castle_id,int index,const char *name)
{
	struct eventlist *ev;
	int code=castle_id|(index<<16);
	
	if( name==NULL || *name==0 )
		return 0;
		
	if( (ev=calloc(sizeof(struct eventlist), 1))==NULL ){
		printf("guild_addcastleinfoevent: out of memory !!");
		exit(0);
	}
	memcpy(ev->name,name,sizeof(ev->name));
	ev->next=numdb_search(guild_castleinfoevent_db,code);
	numdb_insert(guild_castleinfoevent_db,code,ev);
	return 0;
}

// 僊儖僪忛僨乕僞梫媮曉怣
int guild_castledataloadack(int castle_id,int index,int value)
{
	struct guild_castle *gc=guild_castle_search(castle_id);
	int code=castle_id|(index<<16);
	struct eventlist *ev,*ev2;
	
	if(gc==NULL){
		return 0;
	}
	switch(index){
	case 1: gc->guild_id = value; break;
	case 2: gc->economy = value; break;
	case 3: gc->defense = value; break;
	case 4: gc->triggerE = value; break;
	case 5: gc->triggerD = value; break;
	case 6: gc->nextTime = value; break;
	case 7: gc->payTime = value; break;
	case 8: gc->createTime = value; break;
	case 9: gc->visibleC = value; break;
	case 10: gc->visibleG0 = value; break;
	case 11: gc->visibleG1 = value; break;
	case 12: gc->visibleG2 = value; break;
	case 13: gc->visibleG3 = value; break;
	case 14: gc->visibleG4 = value; break;
	case 15: gc->visibleG5 = value; break;
	case 16: gc->visibleG6 = value; break;
	case 17: gc->visibleG7 = value; break;
	default:
		printf("guild_castledataloadack ERROR!! (Not found index=%d)\n", index);
		return 0;
	}
	if( (ev=numdb_search(guild_castleinfoevent_db,code))!=NULL ){
		numdb_erase(guild_castleinfoevent_db,code);
		for(;ev;ev2=ev->next,free(ev),ev=ev2){
			npc_event_do(ev->name);
		}
	}
	return 1;
}
// 僊儖僪忛僨乕僞曄峏梫媮
int guild_castledatasave(int castle_id,int index,int value)
{
	return intif_guild_castle_datasave(castle_id,index,value);
}

// 僊儖僪忛僨乕僞曄峏捠抦
int guild_castledatasaveack(int castle_id,int index,int value)
{
	struct guild_castle *gc=guild_castle_search(castle_id);
	if(gc==NULL){
		return 0;
	}
	switch(index){
	case 1: gc->guild_id = value; break;
	case 2: gc->economy = value; break;
	case 3: gc->defense = value; break;
	case 4: gc->triggerE = value; break;
	case 5: gc->triggerD = value; break;
	case 6: gc->nextTime = value; break;
	case 7: gc->payTime = value; break;
	case 8: gc->createTime = value; break;
	case 9: gc->visibleC = value; break;
	case 10: gc->visibleG0 = value; break;
	case 11: gc->visibleG1 = value; break;
	case 12: gc->visibleG2 = value; break;
	case 13: gc->visibleG3 = value; break;
	case 14: gc->visibleG4 = value; break;
	case 15: gc->visibleG5 = value; break;
	case 16: gc->visibleG6 = value; break;
	case 17: gc->visibleG7 = value; break;
	default:
		printf("guild_castledatasaveack ERROR!! (Not found index=%d)\n", index);
		return 0;
	}
	return 1;
}

// 僊儖僪僨乕僞堦妵庴怣乮弶婜壔帪乯
int guild_castlealldataload(int len,struct guild_castle *gc)
{
	int i;
	int n=(len-4)/sizeof(struct guild_castle),ev=-1;

	// 僀儀儞僩晅偒偱梫媮偡傞僨乕僞埵抲傪扵偡(嵟屻偺愯嫆僨乕僞)
	for(i=0;i<n;i++){
		if( (gc+i)->guild_id )
			ev=i;
	}

	// 忛僨乕僞奿擺偲僊儖僪忣曬梫媮
	for(i=0;i<n;i++,gc++){
		struct guild_castle *c=guild_castle_search(gc->castle_id);
		if(!c){
			printf("guild_castlealldataload ??\n");
			continue;
		}
		memcpy(&c->guild_id,&gc->guild_id,
			sizeof(struct guild_castle) - ((int)&c->guild_id - (int)c) );
		if( c->guild_id ){
			if(i!=ev)
				guild_request_info(c->guild_id);
			else
				guild_npc_request_info(c->guild_id,"::OnAgitInit");
		}
	}
	if(ev==-1)
		npc_event_doall("OnAgitInit");
	return 0;
}


int guild_agit_start(void)
{	// Run All NPC_Event[OnAgitStart]
	int c = npc_event_doall("OnAgitStart");
	printf("NPC_Event:[OnAgitStart] Run (%d) Events by @AgitStart.\n",c);
	return 0;
}

int guild_agit_end(void)
{	// Run All NPC_Event[OnAgitEnd]
	int c = npc_event_doall("OnAgitEnd");
	printf("NPC_Event:[OnAgitEnd] Run (%d) Events by @AgitEnd.\n",c);
	return 0;
}

int guild_gvg_eliminate_timer(int tid,unsigned int tick,int id,int data)
{	// Run One NPC_Event[OnAgitEliminate]
	size_t len = strlen((const char*)data);
	char *evname=(char*)calloc(len + 4, 1);
	if (evname == NULL) {
		printf("out of memory: guild_gvg_eliminate_timer\n");
		exit(1);
	}
	int c=0;
	if(!agit_flag) return 0;	// Agit already End
	memcpy(evname,(const char *)data,len - 5);
	strcpy(evname + len - 5,"Eliminate");
	c = npc_event_do(evname);
	printf("NPC_Event:[%s] Run (%d) Events.\n",evname,c);
	return 0;
}

int guild_agit_break(struct mob_data *md)
{	// Run One NPC_Event[OnAgitBreak]
	char *evname=calloc(strlen(md->npc_event) + 1, 1);
	if (evname == NULL) {
		printf("out of memory: guild_agit_break\n");
		exit(1);
	}
	strcpy(evname,md->npc_event);
// Now By User to Run [OnAgitBreak] NPC Event...
// It's a little impossible to null point with player disconnect in this!
// But Script will be stop, so nothing...
// Maybe will be changed in the futher..
//      int c = npc_event_do(evname);
	if(!agit_flag) return 0;	// Agit already End
	add_timer(gettick()+battle_config.gvg_eliminate_time,guild_gvg_eliminate_timer,md->bl.m,(int)evname);
	return 0;
}