item.c

石器时代8.0服务端完整源代码。可以直接编译

{
	if( ITEM_DATAINTNUM <= index || index < 0 )return FALSE;
	return TRUE;
}

static INLINE int ITEM_CHECKCHARDATAINDEX(int index)
{
	if( ITEM_DATACHARNUM<=index || index<0 )return FALSE;
	return TRUE;
}

BOOL ITEM_initExistItemsArray( int num )
{
	int     i;

	BOOL ITEM_checksetdata( void );
	if( ITEM_checksetdata() == FALSE )return FALSE;

	ITEM_itemnum = num;

	ITEM_item = allocateMemory( sizeof( ITEM_exists ) * num );
	if( ITEM_item == NULL ) return FALSE;

	for( i = 0 ; i < num ; i ++ ){
		memset( &ITEM_item[i], 0 , sizeof( ITEM_exists ));
		ITEM_item[i].use = FALSE;
	}

	return TRUE;
}

BOOL ITEM_endExistItemsArray( void )
{
	freeMemory( ITEM_item );
	return TRUE;
}

int _ITEM_initExistItemsOne( char *file, int line, ITEM_Item* itm )
{
	int i;
	int itemID=-1;
	static int Sindex=1;
	itemID = itm->data[ITEM_ID];
	if( ITEM_CHECKITEMTABLE(itm->data[ITEM_ID] ) == FALSE){
		print("CHAR itemData err Item_id:%d=%s%d!!\n", itm->data[ITEM_ID], file, line);
		return -1;
	}
	for( i = 0 ; i < ITEM_itemnum ; i ++ ) {
		Sindex++;
		if( Sindex >= ITEM_itemnum ) Sindex = 1;
		if( Sindex < 1 ) Sindex = 1;
		if( !ITEM_item[Sindex].use){
			int	charaindex;
			charaindex = ITEM_item[Sindex].itm.workint[ITEM_WORKCHARAINDEX];
			if( CHAR_CHECKINDEX( charaindex) &&
				CHAR_getInt( charaindex, CHAR_WHICHTYPE) == CHAR_TYPEPLAYER ) {
				int	j;
				for( j = 0; j < CHAR_MAXITEMHAVE; j ++ ) {
					if( CHAR_getItemIndex( charaindex, j) == Sindex) {
						print( "item.c: error! chara have this item charaindex[%d] "
								"itemindex[%d] Name(%s)POS(%d)NAME(%s)\n",
								charaindex, Sindex,
								CHAR_getUseName( charaindex ), j,
								ITEM_item[Sindex].itm.string[ITEM_NAME].string );
						print( "from %s:%d\n", file, line);
						ITEM_item[Sindex].use = TRUE;
						break;
					}
				}
				if( j != CHAR_MAXITEMHAVE ) continue;
			}
			memcpy( &ITEM_item[Sindex].itm , itm , sizeof( ITEM_Item ) );
			ITEM_item[Sindex].use = TRUE;
			{
				BOOL    (*initfunc)(ITEM_Item*)=NULL;
				initfunc = (BOOL(*)(ITEM_Item*)) getFunctionPointerFromName( itm->string[ITEM_INITFUNC].string );
				if( initfunc ){
					if( initfunc( &ITEM_item[Sindex].itm ) == FALSE ){
						ITEM_item[Sindex].use = FALSE;
						fprint( "Error:Can't init item\n" );
						return -1;
					}
				}
			}
			ITEM_UseItemnum++;
			ITEM_constructFunctable( Sindex);
			return Sindex;
		}
	}
	fprint( "错误:物品已满\n" );
	return -1;
}

void _ITEM_endExistItemsOne( int index , char *file, int line)
{
	int	i,j;
	int  hitcnt = 0;
	int     playernum = CHAR_getPlayerMaxNum();

	if( !ITEM_CHECKINDEX(index)) return;

	for( i = 0; i < playernum; i ++ ) {
		if( CHAR_CHECKINDEX( i)) {
			for( j = 0; j < CHAR_MAXITEMHAVE; j ++ ) {
				if( CHAR_getItemIndex( i, j) == index) {
					print( "warning !! player have this item:%d call from [%s:%d](%s)(%s)\n",
							index, file,line, CHAR_getUseName(i),ITEM_item[index].itm.string[ITEM_NAME].string );
					hitcnt ++;
					if( hitcnt > 1 ) {
						print( "ITEM_INDEX(%d) duplicate!!\n", index);
					}
				}
			}
		}
	}

	if( hitcnt < 1 ){
		ITEM_item[index].use = FALSE;
		ITEM_item[index].itm.workint[ITEM_WORKCHARAINDEX] = -1;
		ITEM_UseItemnum--;
	}
}

INLINE int ITEM_getIntStrict( int index ,ITEM_DATAINT element,int* error)
{
	if(!ITEM_CHECKINDEX(index))return *error=FALSE;
	if(!ITEM_CHECKINTDATAINDEX(element))return *error=FALSE;
	return ITEM_item[index].itm.data[element];
}

INLINE int _ITEM_getInt( char *file, int line, int index ,ITEM_DATAINT element)
{
	if(!ITEM_CHECKINDEX(index)){
		return -1;
	}
	if(!ITEM_CHECKINTDATAINDEX(element))	{
		return -1;
	}
	return ITEM_item[index].itm.data[element];
}

INLINE int ITEM_setIntStrict( int index ,ITEM_DATAINT element,int data,
							  int* error)
{
	int buf;
	if(!ITEM_CHECKINDEX(index))
		return *error=FALSE;
	if(!ITEM_CHECKINTDATAINDEX(element))
		return *error=FALSE;
	buf = ITEM_item[index].itm.data[element];
	ITEM_item[index].itm.data[element] = data;
	return buf;
}

INLINE int _ITEM_setInt( char *file, int line, int index ,ITEM_DATAINT element, int data)
{
	int buf;
	if( !ITEM_CHECKINDEX( index) ){
		return -1;
	}

	if( !ITEM_CHECKINTDATAINDEX( element) ){
		return -1;
	}

	buf = ITEM_item[ index].itm.data[ element];
	ITEM_item[ index].itm.data[ element] = data;
	return buf;
}

INLINE char* ITEM_getChar( int index ,ITEM_DATACHAR element )
{
	if(!ITEM_CHECKINDEX(index))return NULL;
	if(!ITEM_CHECKCHARDATAINDEX(element))return NULL;
	return ITEM_item[index].itm.string[element].string;
}

INLINE BOOL ITEM_setChar( int index ,ITEM_DATACHAR element , char* new)
{
	if(!ITEM_CHECKINDEX(index))return FALSE;
	if(!ITEM_CHECKCHARDATAINDEX(element))return FALSE;
	strcpysafe( ITEM_item[index].itm.string[element].string,
				sizeof( ITEM_item[index].itm.string[element].string ),
				new );
	return TRUE;
}

INLINE int ITEM_getWorkInt( int index ,ITEM_WORKDATAINT element)
{
	if( !ITEM_CHECKINDEX(index) ) return -1;
	if( element >= ITEM_WORKDATAINTNUM || element < 0 ) return -1;
	return ITEM_item[index].itm.workint[element];
}

INLINE int ITEM_setWorkInt( int index ,ITEM_WORKDATAINT element, int data)
{
	int buf;
	if( !ITEM_CHECKINDEX( index) ) return -1;
	if( element >= ITEM_WORKDATAINTNUM || element < 0 ) return -1;

	buf = ITEM_item[index].itm.workint[element];
	ITEM_item[index].itm.workint[element] = data;
	return buf;
}

INLINE int ITEM_getITEM_itemnum( void )
{
	return ITEM_itemnum;
}

INLINE int ITEM_getITEM_UseItemnum( void )
{
	return ITEM_UseItemnum;
}


INLINE BOOL ITEM_getITEM_use( int index )
{
	if( !ITEM_CHECKINDEX(index))return FALSE;
	return ITEM_item[index].use;
}

void ITEM_constructFunctable( int itemindex )
{
	int     i;
	if( !ITEM_CHECKINDEX(itemindex))return;

	for( i=ITEM_FIRSTFUNCTION; i < ITEM_LASTFUNCTION ; i++ )	{
		ITEM_item[itemindex].itm.functable[i-ITEM_FIRSTFUNCTION]
			= getFunctionPointerFromName( ITEM_getChar( itemindex,i ) );
	}
}

void* ITEM_getFunctionPointer( int itemindex, int functype )
{
	if( !ITEM_CHECKINDEX(itemindex) )return NULL;
	if( functype < ITEM_FIRSTFUNCTION  || functype >= ITEM_LASTFUNCTION ){
		print( "类型错误:%d\n", functype);
		return NULL;
	}
	return ITEM_item[itemindex].itm.
		functable[functype-ITEM_FIRSTFUNCTION];
}

int ITEM_getItemMaxIdNum( void)
{
	return ITEM_tblen;
}

BOOL ITEM_checksetdata( void )
{
	int i;
	char*   strings[ITEM_DATAINTNUM + ITEM_DATACHARNUM + 1];
#ifdef _SIMPLIFY_ITEMSTRING
	int num=0;
	for(i = 0; i < arraysizeof( ITEM_setintdata) ; i ++ )
		strings[ num++ ] = ITEM_setintdata[i].dumpchar;
	for( i = 0 ; i < arraysizeof( ITEM_setchardata) ; i ++ )
		strings[ num++ ] = ITEM_setchardata[i].dumpchar;
	strings[ITEM_DATAINTNUM+ITEM_DATACHARNUM] = ITEM_setmemdata.dumpchar;

	if( ! checkStringsUnique( strings, num,1 ) ){
		fprint( "ITEM_set????data is overlapped.\nIt is not allowed\n");
		return FALSE;
	}
#else
	for(i = 0; i < ITEM_DATAINTNUM ; i ++ )
		strings[i] = ITEM_setintdata[i].dumpchar;
	for( i = 0 ; i < ITEM_DATACHARNUM ; i ++ )
		strings[ITEM_DATAINTNUM+i] = ITEM_setchardata[i].dumpchar;
	

	strings[ITEM_DATAINTNUM+ITEM_DATACHARNUM] = ITEM_setmemdata.dumpchar;

	if( ! checkStringsUnique( strings, arraysizeof( strings ),1 ) ){
		fprint( "ITEM_set????data is overlapped.\nIt is not allowed\n");
		return FALSE;
	}
#endif
	return TRUE;
}

static char    ITEM_dataString[STRINGBUFSIZ];
char* ITEM_makeStringFromItemIndex( int index, int mode )
{
	if( 0 <= index && index < ITEM_itemnum && ITEM_item[index].use == TRUE)
		;
	else
		return NULL;
	return ITEM_makeStringFromItemData( &ITEM_item[index].itm, mode );
}

#ifdef _SIMPLIFY_ITEMSTRING2
BOOL CHECK_HaveBeSave( int itemID, int oneNum, int type )
{
	if( ITEM_ID == type ) return TRUE;
	if( ITEMTBL_getInt( itemID, type) == oneNum ) return FALSE;
	return TRUE;
}
#endif

char*   ITEM_makeStringFromItemData( ITEM_Item* one, int mode )
{
	int     i;
	char	delim1 = '\0';
	char	delim2 = '\0';
	int     strlength=0;

#ifdef _SIMPLIFY_ITEMSTRING2
	int itemID = one->data[ ITEM_ID];
	if( !ITEM_CHECKITEMTABLE( itemID) ) return NULL;
#endif
	if( mode == 0 ) {
		delim1 = '=';	delim2 = '|';
	}else {
		delim1 = ':';	delim2 = ',';
	}

#ifdef _SIMPLIFY_ITEMSTRING
	for(i = 0; i < arraysizeof( ITEM_setintdata) ; i ++ ){
		char    linedata[128];
#ifdef _SIMPLIFY_ITEMSTRING2
		if( !CHECK_HaveBeSave( itemID, one->data[ ITEM_setintdata[i].table], ITEM_setintdata[i].table) ) continue;
#endif
		snprintf( linedata , sizeof(linedata),
				  "%s%c%d%c", ITEM_setintdata[i].dumpchar, delim1,
				  one->data[ ITEM_setintdata[i].table], delim2 );
		strcpysafe( &ITEM_dataString[strlength], sizeof( ITEM_dataString ) - strlength, linedata );
		strlength += strlen( linedata );
	}

	for( i = 0 ; i < arraysizeof( ITEM_setchardata) ; i ++ ){
		char    linedata[128];
		char    escapebuffer[128];
		if( strlen( one->string[ ITEM_setchardata[i].table].string) == 0 ) continue;

		snprintf( linedata , sizeof(linedata),
				"%s%c%s%c", ITEM_setchardata[i].dumpchar,delim1,
				makeEscapeString( one->string[ITEM_setchardata[i].table].string, escapebuffer,
				sizeof(escapebuffer)), delim2);
		strcpysafe( &ITEM_dataString[strlength], sizeof( ITEM_dataString ) - strlength, linedata );
		strlength += strlen( linedata );
	}
#else
	for( i = 0 ; i < ITEM_DATAINTNUM ; i ++ ) {
		char    linedata[128];
		snprintf( linedata , sizeof(linedata),
				  "%s%c%d%c", ITEM_setintdata[i].dumpchar, delim1, one->data[i], delim2 );
		strcpysafe( &ITEM_dataString[strlength], sizeof( ITEM_dataString ) - strlength, linedata );
		strlength += strlen( linedata );
	}

	for( i = 0 ; i < ITEM_DATACHARNUM ; i ++ ){
		char    linedata[128];
		char    escapebuffer[128];
		if( strlen( one->string[i].string) != 0 ) {
			snprintf( linedata , sizeof(linedata),
					"%s%c%s%c", ITEM_setchardata[i].dumpchar,delim1,
					makeEscapeString(one->string[i].string,escapebuffer,
					sizeof(escapebuffer)), delim2);
			strcpysafe( &ITEM_dataString[strlength], sizeof( ITEM_dataString ) - strlength, linedata );
			strlength += strlen( linedata );
		}
	}
#endif
	dchop( ITEM_dataString, (mode == 0 ) ? "|" : ",");
	return ITEM_dataString;
}

BOOL ITEM_makeExistItemsFromStringToArg( char* src , ITEM_Item* item, int mode )
{
	int     readindex=1;
	char	delim1[2];
	char	delim2[2];

	if( mode == 0 ) {
		strcpy( delim1, "=");
		strcpy( delim2, "|");
	}
	else {
		strcpy( delim1, ":");
		strcpy( delim2, ",");
	}
#ifdef _SIMPLIFY_ITEMSTRING
	{

		int itemID=-1;
		while( 1 ){
			char    linebuf[512];
			char firstToken[256];
			char secondToken[256];
			if( getStringFromIndexWithDelim( src ,delim2 , readindex, linebuf, sizeof( linebuf)) == FALSE ) break;

			readindex++;
			if( getStringFromIndexWithDelim( linebuf, delim1, 1, firstToken, sizeof( firstToken )) == FALSE )return FALSE;
			if( strcmp( firstToken, "id" ) ) continue;
			strcpysafe( secondToken , sizeof( secondToken ), linebuf + strlen( firstToken) + strlen( delim1) );
			itemID = atoi( secondToken);
			if( !ITEM_CHECKITEMTABLE( itemID) ) return FALSE;
			ITEM_getDefaultItemData( itemID, item);
			break;
		}
		readindex =1;
	}
#else
	ITEM_getDefaultItemSetting(item);
#endif

	while( 1 ){
		BOOL    ret;
		char    linebuf[512];

		char firstToken[256];
		char secondToken[256];
		int     i;

		ret = getStringFromIndexWithDelim( src ,delim2 , readindex,linebuf, sizeof(linebuf) );
		if( ret == FALSE )
			break;
		ret = getStringFromIndexWithDelim( linebuf, delim1,  1, firstToken, sizeof( firstToken ) );
		if( ret == FALSE )  return FALSE;
		strcpysafe( secondToken , sizeof( secondToken ),
					linebuf + strlen(firstToken) + strlen(delim1) );
#ifdef _SIMPLIFY_ITEMSTRING
		for(i = 0; i < arraysizeof( ITEM_setintdata) ; i ++ ){
			if( strcmp( firstToken , ITEM_setintdata[i].dumpchar) ) continue;
			item->data[ITEM_setintdata[i].table] = atoi( secondToken );
			goto NEXT;
		}

		for(i = 0; i < arraysizeof( ITEM_setchardata) ; i ++ ){
			if( strcmp(firstToken ,ITEM_setchardata[i].dumpchar ) ) continue;
			strcpysafe( item->string[ ITEM_setchardata[i].table].string,
						sizeof(item->string[ITEM_setchardata[i].table].string),
						makeStringFromEscaped(secondToken));
			goto NEXT;
		}
#else
		for( i = 0 ; i < ITEM_DATAINTNUM ; i ++ ){
			if( strcmp(firstToken ,ITEM_setintdata[i].dumpchar) == 0 ){
				item->data[i] = atoi( secondToken );
				goto NEXT;
			}
		}

		for( i = 0 ; i < ITEM_DATACHARNUM ; i ++ ){
			if( strcmp(firstToken ,ITEM_setchardata[i].dumpchar ) == 0 ){
				strcpysafe( item->string[i].string,
							sizeof(item->string[i].string),
							makeStringFromEscaped(secondToken));
				goto NEXT;
			}
		}
#endif
		fprint( "??? : %s[%s]\n" , src , firstToken );

	NEXT: