item.cpp

idbot08源码

{
	switch(code_id)
	{
	case 7758186: //jav
	case 6384185: //9ja
	case 6384183: //7ja

	case 7889268: //tax
	case 6386745: //9ta
	case 6386743: //7ta

	case 6712180: //tkf
	case 7042105: //9tk
	case 7042103: //7tk

	case 3501409: //am5
	case 6384993: //ama
	case 6712673: //amf

	case 7104880: //pil
	case 6910009: //9pi
	case 6910007: //7pi

	case 6712162: //bkf
	case 7037497: //9bk
	case 7037495: //7bk

	case 7102818: //bal
	case 3695161: //9b8
	case 3695159: //7b8

	case 7760999: //glv
	case 7104313: //9gl
	case 7104311: //7gl

	case 7369588: //tsp
	case 7566393: //9ts
	case 7566391: //7ts

		return TRUE;
	default: 
		return FALSE;
	}
}

char * CD2Item::GetColorCode()
{
	static char *cr_tb[10]={"","Inferior ","","Superior ","$$3","$$:","$$9","$$4","$$8","$$4Rune Word $$5"};
	static char *cr_tb_shocket[4]={"","$$5Inferior ","$$5","$$5Superior "};
	if(this->isRuneWord)
		return cr_tb[9];

	if(ItemQuality<4 && this->hasSockets)
		return cr_tb_shocket[ItemQuality];

	return cr_tb[ItemQuality];
}

int CD2Item::OperatorPriority(char op)
{
	switch(op)
	{
	case '*': return 5;
	case '/': return 5;
	case '+': return 4;
	case '-': return 4;
	case '=': return 3;
	case '#': return 3;
	case ']': return 3;
	case '[': return 3;
	case '>': return 3;
	case '<': return 3;
	case ',': return 2;
	case '|': return 1;
	case '(': return 0;
	case ')': return 0;
	default: return -1;
	}
}

int CD2Item::OpFunction(int l, int r, char op)
{
	int res;
	switch(op)
	{
	case '*': res= l*r;break;
	case '/':
		if(r)
		{
			res= l/r;
		}
		else
		{
			if(_debug)D2Print("$$1Error: Divided by zero.");
			res= 0;
		}
		break;
	case '+': res= l+r;break;
	case '-': res= l-r;break;
	case ']':
		res= (l>=r);
		if(_debug)D2Print("%d>=%d$$5=$$0%d",l,r,res);
		return res;
	case '[': 
		res= (l<=r);
		if(_debug)D2Print("%d<=%d$$5=$$0%d",l,r,res);
		return res;
	case '=': res= (l==r);break;
	case '>': res= (l>r);break;
	case '<': res= (l<r);break;
	case '#':
		res= (l!=r);
		if(_debug)D2Print("%d!=%d$$5=$$0%d",l,r,res);
		return res;
	case ',': res= l&&r;break;
	case '|': res= l||r;break;
	default: res= 0;break;
	}

	if(_debug)D2Print("%d%c%d$$5=$$0%d",l,op,r,res);
	return res;
}

BOOL CD2Item::LoadIdConfig()
{
	#include "itemsize.h"
	ITEM_SIZE *pp = ITEM_SIZE_TB;
	while(pp->code)
	{
		SIZE sz;
		sz.cx=pp->x;
		sz.cy=pp->y;
		_item_size[Code2Number(pp->code)]=sz;
		pp++;
	}

	char filename[MAX_PATH];
	if(!server->GetIniFileName("Identify",filename,MAX_PATH))
		return FALSE;

	LoadIdConfig_ModDef(filename);

	LoadIdConfig_Filter("Unique",ITEM_LEVEL_UNIQUE,filename);
	LoadIdConfig_Filter("Set",ITEM_LEVEL_SET,filename);
	LoadIdConfig_Filter("Rare",ITEM_LEVEL_RARE,filename);
	LoadIdConfig_Filter("Magic",ITEM_LEVEL_MAGIC,filename);
	LoadIdConfig_Filter("Normal",ITEM_LEVEL_NORMAL,filename);

	return TRUE;
}

BOOL CD2Item::LoadIdConfig_ModDef(char *filename)
{
	char kbuf[32000];
	int klen=GetPrivateProfileSection("MODDEF",kbuf,sizeof(kbuf),filename);
	char *p1=kbuf;
	while(p1-kbuf<klen && *p1)
	{
		char *p2=p1;

		while(*p2!='=') p2++;
		*p2=0;
		p2++;

		if(strlen(p2)==0 || *p2==';')
		{
			D2Print("$$1Warning: $$0empty mod: $$9%s",p1);
		}
		_mod_def[p1]=atoi(p2)+1;
		
		p1=p2;
		while(p1-kbuf<klen && *p1)p1++;
		p1++;
	}

	return TRUE;
}

void CD2Item::RemoveBlanks(char *str)
{
	char *p1,buf[1000];
	strcpy(buf,str);

	p1=buf;

	while(*p1 && p1-buf<sizeof(buf))
	{
		if(*p1==' '||*p1=='\t') 
		{
			p1++;
			continue;
		}
		
		*str=*p1;
		p1++;
		str++;
	}
	*str=0;
}

void CD2Item::LoadIdConfig_Filter(char *app,int Level,char *filename)
{
	char filter[10000];

	char kbuf[32000];
	int klen=GetPrivateProfileSection(app,kbuf,sizeof(kbuf),filename);
	char *p1=kbuf;
	while(p1-kbuf<klen && *p1)
	{
		char *p2=p1;
		while(*p2!='=') p2++;
		*p2=0;
		p2++;

		DWORD spec_code;
		if(Level==ITEM_LEVEL_SET||Level==ITEM_LEVEL_UNIQUE)
			spec_code=atoi(p1);
		else 
			spec_code=Code2Number(p1);
		
		sprintf(filter,"%d#%d#%s",Level,spec_code,p2);
		RemoveBlanks(filter);
		int fillen=strlen(filter);

		for(char *p3=filter;p3-filter<fillen;p3++)
		{
			if(*p3==';')
			{
				*p3=0;
				break;
			}
		}


		if(strlen(p2)==0 || *p2==';')
		{
			D2Print("$$1Warning: $$0empty filter: $$9%s",filter);
		}
		else _filter.push_back(filter);

		p1=p2;
		while(p1-kbuf<klen && *p1)p1++;
		p1++;
	}

}

#define FILTER_UNFIT -1
#define FILTER_FAILED 0
#define FILTER_SUCCEEDED 1

int CD2Item::Filter(const char *src)
{
	int Level=atoi(src);
	switch(this->ItemQuality)
	{
	case ITEM_LEVEL_INFERIOR:
	case ITEM_LEVEL_NORMAL:
	case ITEM_LEVEL_SUPERIOR:
		if(Level!=ITEM_LEVEL_NORMAL) return FILTER_UNFIT;
		break;
	case ITEM_LEVEL_MAGIC:
		if(Level!=ITEM_LEVEL_MAGIC) return FILTER_UNFIT;
		break;
	case ITEM_LEVEL_SET:
		if(Level!=ITEM_LEVEL_SET) return FILTER_UNFIT;
		break;
	case ITEM_LEVEL_UNIQUE:
		if(Level!=ITEM_LEVEL_UNIQUE) return FILTER_UNFIT;
		break;
	case ITEM_LEVEL_RARE:
	case ITEM_LEVEL_CRAFT:
		if(Level!=ITEM_LEVEL_RARE) return FILTER_UNFIT;
		break;
	}

	while(*src!='#' && *src)src++;
	if(!*src) return FILTER_UNFIT;
	src++;

	if(Level==ITEM_LEVEL_SET||Level==ITEM_LEVEL_UNIQUE)
	{
		if(atoi(src)!=this->UniqueId) return FILTER_UNFIT;
	}
	else 
	{
		if(atoi(src)!=this->code_id) return FILTER_UNFIT;
	}

	while(*src!='#' && *src)src++;
	if(!*src) return FILTER_UNFIT;
	src++;


	stack<char> op_stack;
	stack<int> num_stack;

	SINGLE_TOKEN token;
	const char *p;
	while((p=GetAToken(src,token))!=NULL)
	{
		switch(token.type)
		{
		case TOKEN_TYPE_BAD:
			return TRUE;
		case TOKEN_TYPE_UNSET:
			break;
		case TOKEN_TYPE_OP:
			if(op_stack.empty())
			{
				op_stack.push(token.op);
				src=p;
			}
			else if(token.op=='(' || OperatorPriority(token.op)>OperatorPriority(op_stack.top()))
			{
				op_stack.push(token.op);
				src=p;
			}
			else
			{
				if(op_stack.empty())
				{
					D2Print("$$1Expression error.");
					return TRUE;
				}

				if(op_stack.top()=='(')
				{
					op_stack.pop();
					if(token.op==')') src=p;
					break;
				}

				if(num_stack.empty())
				{
					D2Print("$$1Expression error.");
					return TRUE;
				}
				int r=num_stack.top();
				num_stack.pop();
				if(num_stack.empty())
				{
					D2Print("$$1Expression error.");
					return TRUE;
				}
				int l=num_stack.top();
				num_stack.pop();
				num_stack.push(OpFunction(l,r,op_stack.top()));
				op_stack.pop();
			}
			break;
		case TOKEN_TYPE_NUM:
			num_stack.push(token.num);
			src=p;
			break;
		case TOKEN_TYPE_VAR:
			num_stack.push(VarToNum(token.var));
			if(_debug)
				D2Print("%s$$5=$$3%d",token.var,num_stack.top());
			src=p;
			break;
		}
	}
	while(!op_stack.empty())
	{
		if(op_stack.top()=='(')
		{
			op_stack.pop();
			continue;
		}

		if(num_stack.empty())
		{
			D2Print("$$1Expression error.");
			return TRUE;
		}
		int r=num_stack.top();
		num_stack.pop();
		if(num_stack.empty())
		{
			D2Print("$$1Expression error.");
			return TRUE;
		}
		int l=num_stack.top();
		num_stack.pop();
		num_stack.push(OpFunction(l,r,op_stack.top()));
		op_stack.pop();
	}

	if(num_stack.size()>1)
	{
		D2Print("$$1Expression error.");
		return TRUE;
	}
	if(_debug)D2Print("Result$$5=$$%d%d",!!num_stack.top()+1,!!num_stack.top());
	return num_stack.top();
}


BOOL CD2Item::Identify()
{
	if(!this->isIdentified)return TRUE;
	if(	this->mod_num==0 ) 
	{
		if(ItemQuality==ITEM_LEVEL_MAGIC||ItemQuality==ITEM_LEVEL_SET||ItemQuality==ITEM_LEVEL_UNIQUE)
			return TRUE;

		if(ItemQuality==ITEM_LEVEL_RARE||ItemQuality==ITEM_LEVEL_CRAFT)
		{
			isUselessItem=TRUE;
			return FALSE;
		}
	}

	BOOL filter_defined=FALSE;
	list<string>::iterator i;
	for(i=_filter.begin();i!=_filter.end();i++)
	{
		switch(Filter(i->c_str()))
		{
		case FILTER_SUCCEEDED:
			return TRUE;
		case FILTER_FAILED:
			filter_defined=TRUE;
			continue;
		default:
			continue;
		}
	}

	if(filter_defined)
	{
		isUselessItem=TRUE;
		return FALSE;
	}
	else return TRUE;
}

const char* CD2Item::GetAToken(const char *p,SINGLE_TOKEN&token)
{
	token.type=TOKEN_TYPE_OP;

	switch(*p)
	{
	case 0: 
		token.type=TOKEN_TYPE_UNSET;
		return NULL;
	case ':': 
		token.op=']';
		return p+1;
	case '>': 
		if(p[1]=='=')
		{
			token.op=']';
			return p+2;
		}
		token.op='>';
		return p+1;
	case '<':
		if(p[1]=='=')
		{
			token.op='[';
			return p+2;
		}
		token.op='<';
		return p+1;
	case ',':
		token.op=',';
		return p+1;
	case '&': 
		if(p[1]=='&')
		{
			token.op=',';
			return p+2;;
		}
		break;
	case '!':
		if(p[1]=='=')
		{
			token.op='#';
			return p+2;;
		}
		break;
	case '|':
		token.op='|';
		if(p[1]=='|')
		{
			return p+2;;
		}
		return p+1;
	case '=': 
		token.op='=';
		if(p[1]=='=')
		{
			return p+2;;
		}
		return p+1;
	case ')': 
	case '(': 
	case '*': 
	case '/': 
	case '+': 
	case '-': 
		token.op=*p;
		return p+1;
	}

	if(*p>='A'&&*p<='Z' ||*p>='a'&&*p<='z')
	{
		//变量
		token.type=TOKEN_TYPE_VAR;
		char *pdst=token.var;
		while(*p>='A'&&*p<='Z' ||*p>='a'&&*p<='z'||*p>='0'&&*p<='9'||*p=='_'||*p=='%')
		{
			if(pdst-token.var<sizeof(token.var)-1)
			{
				*pdst=*p;
				pdst++;
			}

			p++;
		}
		*pdst=0;
		return p;
	}
	else if(*p>='0'&&*p<='9')
	{
		//变量
		token.type=TOKEN_TYPE_NUM;
		token.num=atoi(p);

		while(*p>='0'&&*p<='9')p++;
		return p;
	}
	else 
	{
		D2Print("$$1Expression error: bad character '%c'",*p);
		token.type=TOKEN_TYPE_BAD;
		return p;
	}
}


int CD2Item::VarToNum(char *var)
{
	if(strcmp("basedef",var)==0)
		return this->nDefense;
	if(strcmp("eth",var)==0)
		return this->isEthereal;
	if(strcmp("socket",var)==0)
		return this->nSocket;
	if(strcmp("ilvl",var)==0)
		return this->Ilvl;
	if(strcmp("durability",var)==0)
		return this->nDur;
	if(strcmp("max_durability",var)==0)
		return this->nMaxDur;
	if(strcmp("quantity",var)==0)
		return this->nQuantity;
	

	//换成属性id
	int modid=_mod_def[var];
	if(!modid) 
	{
		D2Print("$$1Undifined Mod:$$1 %s",var);
		return 0;
	}
	
	modid--;
	int secid=0;

	if(modid>=10000)
	{
		secid=modid%10000;
		modid/=10000;
	}
	
	for(int i=0;i<mod_num;i++)
	{
		ITEM_MOD *p=&mod[i];
		if(p->id==188 && modid==126 && p->value[0]==secid)
		{
			return p->value[1];
		}


		if(modid==126)
		{
			if(p->id>188) break;
		}
		else 
		{
			if(p->id>modid) break;
		}

		if(p->id<modid) continue;

		switch(modid)
		{
		case 97://+skill 
		case 83://+skill_class 
		case 126://+skill_table
		case 107://+skill_spec
		case 204://skill charge
			if(p->value[0]==secid) return p->value[1];
			break;
		case 195://skill attack
		case 196://skill kill
		case 197://skill die
		case 198://skill striking
		case 199://skill level up
		case 201://skill struck
			if(p->value[1]==secid) return p->value[0];
			break;
		case 57:
			return p->value[1];
		default:
			return p->value[0];
		}
	}
	
	return 0;
}


SIZE CD2Item::GetItemSize()
{
	SIZE sz={0,0};
	if(isEar)
	{
		sz.cx=1;
		sz.cy=1;
		return sz;
	}

	if(_item_size.find(code_id)!=_item_size.end())
	{
		sz=_item_size[code_id];
	}

	if(sz.cx==0||sz.cy==0)
	{
		sz.cx=2;
		sz.cy=4;
	}
	return sz;
}