guild.c

最新的仙镜传说服务器C语言源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "guild.h"
#include "storage.h"
#include "db.h"
#include "timer.h"
#include "battle.h"
#include "npc.h"
#include "pc.h"
#include "map.h"
#include "mob.h"
#include "intif.h"
#include "clif.h"
#include "socket.h"

static struct dbt *guild_db;
static struct dbt *castle_db;
static struct dbt *guild_expcache_db;
static struct dbt *guild_infoevent_db;
static struct dbt *guild_castleinfoevent_db;

struct eventlist {
	char name[50];
	struct eventlist *next;
};

// 僊儖僪偺EXP僉儍僢僔儏偺僼儔僢僔儏偵娭楢偡傞掕悢
#define GUILD_PAYEXP_INVERVAL 10000	// 娫妘(僉儍僢僔儏偺嵟戝惗懚帪娫丄儈儕昩)
#define GUILD_PAYEXP_LIST 8192	// 僉儍僢僔儏偺嵟戝悢

// 僊儖僪偺EXP僉儍僢僔儏
struct guild_expcache {
	int guild_id, account_id, char_id, exp;
};

// 僊儖僪僗僉儖db偺傾僋僙僒乮崱偼捈懪偪偱戙梡乯
int guild_skill_get_inf(int id){ return 0; }
int guild_skill_get_sp(int id,int lv){ return 0; }
int guild_skill_get_range(int id){ return 0; }
int guild_skill_get_max(int id){ return (id==10004)?10:1; }

// 僊儖僪僗僉儖偑偁傞偐妋擣
int guild_checkskill(struct guild *g,int id){ return g->skill[id-10000].lv; }


int guild_payexp_timer(int tid,unsigned int tick,int id,int data);
int guild_gvg_eliminate_timer(int tid,unsigned int tick,int id,int data);


static int guild_read_castledb(void)
{
	FILE *fp;
	char line[1024];
	int j,ln=0;
	char *str[32],*p;
	struct guild_castle *gc;

	if( (fp=fopen("db/castle_db.txt","r"))==NULL){
		printf("can't read db/castle_db.txt\n");
		return -1;
	}

	while(fgets(line,1020,fp)){
		if(line[0]=='/' && line[1]=='/')
			continue;
		memset(str,0,sizeof(str));
		gc=calloc(sizeof(struct guild_castle), 1);
		if(gc==NULL){
			printf("guild: out of memory!\n");
			exit(0);
		}
		for(j=0,p=line;j<5 && p;j++){
			str[j]=p;
			p=strchr(p,',');
			if(p) *p++=0;
		}

		gc->guild_id=0; // <Agit> Clear Data for Initialize
		gc->economy=0; gc->defense=0; gc->triggerE=0; gc->triggerD=0; gc->nextTime=0; gc->payTime=0;
		gc->createTime=0; gc->visibleC=0; gc->visibleG0=0; gc->visibleG1=0; gc->visibleG2=0;
		gc->visibleG3=0; gc->visibleG4=0; gc->visibleG5=0; gc->visibleG6=0; gc->visibleG7=0;

		gc->castle_id=atoi(str[0]);
		memcpy(gc->map_name,str[1],24);
		memcpy(gc->castle_name,str[2],24);

		numdb_insert(castle_db,gc->castle_id,gc);

		//intif_guild_castle_info(gc->castle_id);

		ln++;
	}
	fclose(fp);
	printf("read db/castle_db.txt done (count=%d)\n",ln);
	return 0;
}

// 弶婜壔
void do_init_guild(void)
{
	guild_db=numdb_init();
	castle_db=numdb_init();
	guild_expcache_db=numdb_init();
	guild_infoevent_db=numdb_init();
	guild_castleinfoevent_db=numdb_init();

	guild_read_castledb();

	add_timer_func_list(guild_gvg_eliminate_timer,"guild_gvg_eliminate_timer");
	add_timer_func_list(guild_payexp_timer,"guild_payexp_timer");
	add_timer_interval(gettick()+GUILD_PAYEXP_INVERVAL,guild_payexp_timer,0,0,GUILD_PAYEXP_INVERVAL);
}


// 専嶕
struct guild *guild_search(int guild_id)
{
	return numdb_search(guild_db,guild_id);
}

struct guild_castle *guild_castle_search(int gcid)
{
	return numdb_search(castle_db,gcid);
}

// mapname偵懳墳偟偨傾僕僩偺gc傪曉偡
struct guild_castle *guild_mapname2gc(char *mapname)
{
	int i;
	struct guild_castle *gc=NULL;
	for(i=0;i<MAX_GUILDCASTLE;i++){
		gc=guild_castle_search(i);
		if(!gc) continue;
		if(strcmp(gc->map_name,mapname)==0) return gc;
	}
	return NULL;
}

// 儘僌僀儞拞偺僊儖僪儊儞僶乕偺侾恖偺sd傪曉偡
struct map_session_data *guild_getavailablesd(struct guild *g)
{
	int i;
	for(i=0;i<g->max_member;i++)
		if(g->member[i].sd!=NULL)
			return g->member[i].sd;
	return NULL;
}

// 僊儖僪儊儞僶乕偺僀儞僨僢僋僗傪曉偡
int guild_getindex(struct guild *g,int account_id,int char_id)
{
	int i;
	if(g==NULL)
		return -1;
	for(i=0;i<g->max_member;i++)
		if( g->member[i].account_id==account_id &&
			g->member[i].char_id==char_id )
			return i;
	return -1;
}
// 僊儖僪儊儞僶乕偺栶怑傪曉偡
int guild_getposition(struct map_session_data *sd,struct guild *g)
{
	int i;
	if(g==NULL && (g=guild_search(sd->status.guild_id))==NULL)
		return -1;
	for(i=0;i<g->max_member;i++)
		if( g->member[i].account_id==sd->status.account_id &&
			g->member[i].char_id==sd->status.char_id )
			return g->member[i].position;
	return -1;
}

// 儊儞僶乕忣曬偺嶌惉
void guild_makemember(struct guild_member *m,struct map_session_data *sd)
{
	memset(m,0,sizeof(struct guild_member));
	m->account_id	=sd->status.account_id;
	m->char_id		=sd->status.char_id;
	m->hair			=sd->status.hair;
	m->hair_color	=sd->status.hair_color;
	m->gender		=sd->sex;
	m->class		=sd->status.class;
	m->lv			=sd->status.base_level;
	m->exp			=0;
	m->exp_payper	=0;
	m->online		=1;
	m->position		=MAX_GUILDPOSITION-1;
	memcpy(m->name,sd->status.name,24);
	return;
}
// 僊儖僪嫞崌妋擣
int guild_check_conflict(struct map_session_data *sd)
{
	intif_guild_checkconflict(sd->status.guild_id,
		sd->status.account_id,sd->status.char_id);
	return 0;
}

// 僊儖僪偺EXP僉儍僢僔儏傪inter嶪偵僼儔僢僔儏偡傞
int guild_payexp_timer_sub(void *key,void *data,va_list ap)
{
	int i, *dellist,*delp, dataid=(int)key;
	struct guild_expcache *c=(struct guild_expcache *)data;
	struct guild *g;
	dellist=va_arg(ap,int *);
	delp=va_arg(ap,int *);
	
	if( *delp>=GUILD_PAYEXP_LIST || (g=guild_search(c->guild_id))==NULL )
		return 0;
	if( ( i=guild_getindex(g,c->account_id,c->char_id) )<0 )
		return 0;
	
	g->member[i].exp+=c->exp;
	intif_guild_change_memberinfo(g->guild_id,c->account_id,c->char_id,
		GMI_EXP,&g->member[i].exp,sizeof(g->member[i].exp));
	c->exp=0;

	dellist[(*delp)++]=dataid;
	free(c);
	return 0;
}
int guild_payexp_timer(int tid,unsigned int tick,int id,int data)
{
	int dellist[GUILD_PAYEXP_LIST],delp=0,i;
	numdb_foreach(guild_expcache_db,guild_payexp_timer_sub,
		dellist,&delp);
	for(i=0;i<delp;i++)
		numdb_erase(guild_expcache_db,dellist[i]);
//	if(battle_config.etc_log)
//		printf("guild exp %d charactor's exp flushed !\n",delp);
	return 0;
}

//------------------------------------------------------------------------

// 嶌惉梫媮
int guild_create(struct map_session_data *sd,char *name)
{
	if(sd->status.guild_id==0){
		if(!battle_config.guild_emperium_check || pc_search_inventory(sd,714) >= 0) {
			struct guild_member m;
			guild_makemember(&m,sd);
			m.position=0;
			intif_guild_create(name,&m);
		} else
			clif_guild_created(sd,3);	// 僄儞儁儕僂儉偑偄側偄
	}else
		clif_guild_created(sd,1);	// 偡偱偵強懏偟偰偄傞

	return 0;
}

// 嶌惉壜斲
int guild_created(int account_id,int guild_id)
{
	struct map_session_data *sd;
	sd=map_id2sd(account_id);
	if(sd==NULL)
		return 0;
	if(guild_id>0) {
			struct guild *g;
			sd->status.guild_id=guild_id;
			sd->guild_sended=0;
			if((g=numdb_search(guild_db,guild_id))!=NULL){
				printf("guild: id already exists!\n");
				exit(1);
			}
			clif_guild_created(sd,0);
			if(battle_config.guild_emperium_check)
				pc_delitem(sd,pc_search_inventory(sd,714),1,0);	// 僄儞儁儕僂儉徚栒
	} else {
		clif_guild_created(sd,2);	// 嶌惉幐攕乮摨柤僊儖僪懚嵼乯
	}
	return 0;
}

// 忣曬梫媮
int guild_request_info(int guild_id)
{
//	if(battle_config.etc_log)
//		printf("guild_request_info\n");
	return intif_guild_request_info(guild_id);
}
// 僀儀儞僩晅偒忣曬梫媮
int guild_npc_request_info(int guild_id,const char *event)
{
	struct eventlist *ev;
	
	if( guild_search(guild_id) ){
		if(event && *event)
			npc_event_do(event);
		return 0;
	}

	if(event==NULL || *event==0)
		return guild_request_info(guild_id);

	if((ev=(struct eventlist *)calloc(sizeof(struct eventlist), 1) )==NULL){
		printf("guild_npc_request_info: out of memory !");
		exit(0);
	}
	memcpy(ev->name,event,sizeof(ev->name));
	ev->next=(struct eventlist *)numdb_search(guild_infoevent_db,guild_id);
	numdb_insert(guild_infoevent_db,guild_id,ev);
	return guild_request_info(guild_id);
}

// 強懏僉儍儔偺妋擣
int guild_check_member(const struct guild *g)
{
	int i;
	struct map_session_data *sd;
	for(i=0;i<fd_max;i++){
		if(session[i] && (sd=session[i]->session_data) && sd->state.auth){
			if(sd->status.guild_id==g->guild_id){
				int j,f=1;
				for(j=0;j<MAX_GUILD;j++){	// 僨乕僞偑偁傞偐
					if(	g->member[j].account_id==sd->status.account_id &&
						g->member[j].char_id==sd->status.char_id)
						f=0;
				}
				if(f){
					sd->status.guild_id=0;
					sd->guild_sended=0;
					sd->guild_emblem_id=0;
					if(battle_config.error_log)
						printf("guild: check_member %d[%s] is not member\n",sd->status.account_id,sd->status.name);
				}
			}
		}
	}
	return 0;
}
// 忣曬強摼幐攕乮偦偺ID偺僉儍儔傪慡晹枹強懏偵偡傞乯
int guild_recv_noinfo(int guild_id)
{
	int i;
	struct map_session_data *sd;
	for(i=0;i<fd_max;i++){
		if(session[i] && (sd=session[i]->session_data) && sd->state.auth){
			if(sd->status.guild_id==guild_id)
				sd->status.guild_id=0;
		}
	}
	return 0;
}
// 忣曬強摼
int guild_recv_info(struct guild *sg)
{
	struct guild *g,before;
	int i,bm,m;
	struct eventlist *ev,*ev2;
	
	if((g=numdb_search(guild_db,sg->guild_id))==NULL){
		g=calloc(sizeof(struct guild), 1);
		if(g==NULL){
			printf("guild_recv_info: out of memory!\n");
			exit(1);
		}
		numdb_insert(guild_db,sg->guild_id,g);
		before=*sg;

		// 嵟弶偺儘乕僪側偺偱儐乕僓乕偺僠僃僢僋傪峴偆
		guild_check_member(sg);
	}else
		before=*g;
	memcpy(g,sg,sizeof(struct guild));

	for(i=bm=m=0;i<g->max_member;i++){	// sd偺愝掕偲恖悢偺妋擣
		if(g->member[i].account_id>0){
			struct map_session_data *sd = map_id2sd(g->member[i].account_id);
			g->member[i].sd=(sd!=NULL &&
				sd->status.char_id==g->member[i].char_id &&
				sd->status.guild_id==g->guild_id)?	sd:NULL;
			m++;
		}else
			g->member[i].sd=NULL;
		if(before.member[i].account_id>0)
			bm++;
	}

	for(i=0;i<g->max_member;i++){	// 忣曬偺憲怣
		struct map_session_data *sd = g->member[i].sd;
		if( sd==NULL )
			continue;

		if(	before.guild_lv!=g->guild_lv || bm!=m ||
			before.max_member!=g->max_member ){
			clif_guild_basicinfo(sd);	// 婎杮忣曬憲怣
			clif_guild_emblem(sd,g);	// 僄儞僽儗儉憲怣
		}

		if(bm!=m){		// 儊儞僶乕忣曬憲怣
			clif_guild_memberlist(g->member[i].sd);
		}

		if( before.skill_point!=g->skill_point)
			clif_guild_skillinfo(sd);	// 僗僉儖忣曬憲怣

		if( sd->guild_sended==0){	// 枹憲怣側傜強懏忣曬傕憲傞
			clif_guild_belonginfo(sd,g);
			clif_guild_notice(sd,g);
			sd->guild_emblem_id=g->emblem_id;
			sd->guild_sended=1;
		}
	}

	// 僀儀儞僩偺敪惗
	if( (ev=numdb_search(guild_infoevent_db,sg->guild_id))!=NULL ){
		numdb_erase(guild_infoevent_db,sg->guild_id);
		for(;ev;ev2=ev->next,free(ev),ev=ev2){
			npc_event_do(ev->name);
		}
	}

	return 0;
}


// 僊儖僪傊偺姪桿
int guild_invite(struct map_session_data *sd,int account_id)
{
	struct map_session_data *tsd= map_id2sd(account_id);
	struct guild *g=guild_search(sd->status.guild_id);
	int i;
	
	if(tsd==NULL || g==NULL)
		return 0;
	if( tsd->status.guild_id>0 || tsd->guild_invite>0 ){	// 憡庤偺強懏妋擣
		clif_guild_inviteack(sd,0);
		return 0;
	}
	
	// 掕堳妋擣
	for(i=0;i<g->max_member;i++)
		if(g->member[i].account_id==0)
			break;
	if(i==g->max_member){
		clif_guild_inviteack(sd,3);
		return 0;
	}

	tsd->guild_invite=sd->status.guild_id;
	tsd->guild_invite_account=sd->status.account_id;