char_base.c.bak

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

}

INLINE int CHAR_setCharPoolPet( int charaindex,int petindex, int new )
{
    int ret;
    if( !CHAR_CHECKINDEX(charaindex))return -1;
    if( !CHAR_CHECKPOOLPETINDEX(petindex))return -1;
    ret = CHAR_getCharPoolPet( charaindex,petindex);

    CHAR_chara[charaindex].indexOfPoolPet[petindex] = new;
    return ret;
}

int CHAR_getCharPetElement( int charaindex )
{
    int i;
    if( !CHAR_CHECKINDEX(charaindex))return -1;
	for( i = 0; i < CHAR_MAXPETHAVE; i ++ ) {
	    if( CHAR_getCharPet( charaindex,i) == -1 ) break;
    }
    return ( i == CHAR_MAXPETHAVE ? -1:i );

}

int CHAR_getCharPoolPetElement( int charaindex )
{
    int i;
	int limit;
    if( !CHAR_CHECKINDEX(charaindex))return -1;

	//andy_reEdit 2003/09/18
	limit = (CHAR_getInt(charaindex,CHAR_TRANSMIGRATION)*2)+5;
	limit = min( limit, CHAR_MAXPOOLPETHAVE);
	for( i = 0; i < limit; i ++ ) {
		if( CHAR_getCharPoolPet( charaindex,i) == -1 ) break;
    }
    return ( i == limit ? -1:i );

}

int CHAR_getCharPoolItemIndexElement( int charaindex )
{
    int i;
    int limit;
    if( !CHAR_CHECKINDEX(charaindex))return -1;
	//andy_reEdit 2003/09/18
	limit = (CHAR_getInt(charaindex,CHAR_TRANSMIGRATION)*4)+10;
	limit = min( limit, CHAR_MAXPOOLITEMHAVE);
	for( i = 0; i < limit; i ++ ) {
	    if( CHAR_getPoolItemIndex( charaindex,i) == -1 ) break;
    }
    // Robin fix
	//return ( i == CHAR_MAXPOOLITEMHAVE ? -1:i );
	return ( i >= limit ? -1:i );

}

int CHAR_getEmptyCharPoolItemIndexNum( int charaindex)
{
	int i, cnt = 0;
    int limit;
    if( !CHAR_CHECKINDEX(charaindex))return 0;
	//andy_reEdit 2003/09/18
	limit = (CHAR_getInt(charaindex,CHAR_TRANSMIGRATION)*4)+10;
	limit = min( limit, CHAR_MAXPOOLITEMHAVE);

	for( i = 0; i < limit; i ++ ) {
		if( CHAR_getPoolItemIndex( charaindex, i) == -1 ) cnt++;
	}
	return cnt;
}

INLINE int _CHAR_getPetSkill( char *file, int line, int petindex, int havepetskillindex )
{
    if( !CHAR_CHECKINDEX(petindex)) {
    	print( "err %s:%d from %s:%d\n", __FILE__, __LINE__, file, line);
    	return -1;
    }
    if( !CHAR_CHECKPETSKILLINDEX(havepetskillindex)) {
    	print( "err %s:%d from %s:%d\n", __FILE__, __LINE__, file, line);
    	return -1;
    }
    return CHAR_chara[petindex].unionTable.indexOfPetskill[havepetskillindex];
}

INLINE int _CHAR_setPetSkill( char *file, int line, int petindex,int havepetskillindex, int new )
{
    int ret;
    if( !CHAR_CHECKINDEX(petindex)) {
    	print( "err %s:%d from %s:%d\n", __FILE__, __LINE__, file, line);
    	return -1;
    }
    if( !CHAR_CHECKPETSKILLINDEX(havepetskillindex)) {
    	print( "err %s:%d from %s:%d\n", __FILE__, __LINE__, file, line);
    	return -1;
    }
    ret = CHAR_getPetSkill( petindex,havepetskillindex);
    CHAR_chara[petindex].unionTable.indexOfPetskill[havepetskillindex] = new;
    return ret;
}

int _CHAR_getPetSkillElement( char *file, int line, int petindex )
{
    int i;
    if( !CHAR_CHECKINDEX(petindex)) {
    	print( "err %s:%d from %s:%d\n", __FILE__, __LINE__, file, line);
    	return -1;
	}
	for( i = 0; i < CHAR_MAXPETSKILLHAVE; i ++ ) {
	    if( CHAR_getPetSkill( petindex,i) == -1 ) break;
    }
    return ( i == CHAR_MAXPETSKILLHAVE ? -1:i );

}

INLINE int CHAR_getCharMakeSequenceNumber( int charaindex )
{
    if( !CHAR_CHECKINDEX(charaindex))return -1;
    return CHAR_chara[charaindex].CharMakeSequenceNumber;
}

void CHAR_constructFunctable( int charaindex )
{
    int     i;
    if( !CHAR_CHECKINDEX(charaindex))return;
    for( i=CHAR_FIRSTFUNCTION; i < CHAR_LASTFUNCTION ; i++ )
        CHAR_chara[charaindex].functable[i-CHAR_FIRSTFUNCTION]
            = getFunctionPointerFromName( CHAR_getCharfunctable( charaindex,i ) );
}

void* CHAR_getFunctionPointer( int charaindex, int functype )
{
    if( !CHAR_CHECKINDEX(charaindex) )return NULL;
    if( functype < CHAR_FIRSTFUNCTION  || functype >= CHAR_LASTFUNCTION )
        return NULL;

    return CHAR_chara[charaindex].functable[functype];
}

BOOL CHAR_initCharArray( int pnum, int petnum,int onum )
{
    int     i;

    BOOL CHAR_checksetdata( void );
    if( CHAR_checksetdata() == FALSE ){
		print(" err CHAR_checksetdata() FALSE !!\n");
		return FALSE;
	}

	//andy_log
	print("#");

    CHAR_initSeekGraphicNumberFromString();
    CHAR_initChatMagic();
	CHAR_charanum = pnum + petnum +onum;

	//andy_log
	print("#");

    CHAR_chara = allocateMemory( sizeof( Char ) * CHAR_charanum );
    if( CHAR_chara == NULL ){
		print("无法分配人物内存 !!\n");
		return FALSE;
	}


	//andy_log
	print("人物内存: %4.2f...", ((float)sizeof( Char )*CHAR_charanum)/1024);

    for( i = 0 ; i < CHAR_charanum ; i ++ ){
		memset( &CHAR_chara[i], 0 , sizeof( Char ));

	}
    for( i = 0 ; i < pnum ; i ++ ){
#ifdef _NPC_SEPARATEDATA
		CHAR_InitCharTempNum( &CHAR_chara[i] );
#endif
	}
    CHAR_playernum = pnum;
    CHAR_petnum = petnum;
    CHAR_othersnum = onum;

    return TRUE;
}

BOOL CHAR_endCharArray( void )
{
#ifdef _NPC_SEPARATEDATA
	CHAR_EndCharTempNum();
#endif
    freeMemory( CHAR_chara );
    CHAR_charanum = 0;
    return TRUE;
}

BOOL CHAR_getCharOnArrayPercentage( int mode, int *max, int *min, int *cnt)
{
	int po=0, Dnums=0;
	po = initCharCounter[0].endcnt;
	*cnt = -1;
	while( 1){
		if( !CHAR_chara[po].use ){
		}else{
			Dnums++;
		}
		po++;
		if( po >= initCharCounter[mode].endcnt ){
			break;
		}
	}
	*cnt = Dnums;
	*max = initCharCounter[mode].endcnt - initCharCounter[mode].startcnt;
	*min = 0;

	return TRUE;
}

int CHAR_initCharOneArray( Char* ch )
{
    int i;
    int mode;
    int ret = TRUE;
    int first;
	static unsigned int CharMakeSequenceNumber = 0;
    if( initCharCounter[0].startcnt == -1 ) {
        initCharCounter[0].startcnt = 0;
        initCharCounter[0].cnt      = initCharCounter[0].startcnt;
        initCharCounter[0].endcnt   = CHAR_playernum;

        initCharCounter[1].startcnt = initCharCounter[0].endcnt;
        initCharCounter[1].cnt      = initCharCounter[0].endcnt;
        initCharCounter[1].endcnt   = CHAR_playernum + CHAR_petnum;

        initCharCounter[2].startcnt = initCharCounter[1].endcnt;
        initCharCounter[2].cnt      = initCharCounter[1].endcnt;
        initCharCounter[2].endcnt   = CHAR_charanum;
    }
    if( ch->data[CHAR_WHICHTYPE] == CHAR_TYPEPLAYER ){
        mode = 0;
    }else if( CHAR_TYPEPET ==  ch->data[CHAR_WHICHTYPE] ) {
        mode = 1;
    }else{
        mode = 2;
    }
    i = initCharCounter[mode].cnt;
    first = TRUE;
    while( 1 ){
        if( !first && i >= initCharCounter[mode].cnt ) {
            ret = FALSE;
            break;
        }
        if( CHAR_chara[i].use == FALSE ){
            ret = TRUE;
            break;
        }else{
            i++;
            if( i >= initCharCounter[mode].endcnt ){
                i = initCharCounter[mode].startcnt;
                first = FALSE;
            }
        }
    }
    if( ret ){
        typedef BOOL (*INITFUNC)(int index);
        INITFUNC initfunc;

#ifdef _NPC_SEPARATEDATA
		ch->tempint = CHAR_chara[i].tempint;
		CHAR_getDefaultCharTempNum( ch);
#endif
        memset( &CHAR_chara[i] , 0, sizeof( Char ) );
        memcpy( &CHAR_chara[i] , ch , sizeof( Char ) );

        initfunc = (INITFUNC)getFunctionPointerFromName(
            ch->charfunctable[CHAR_INITFUNC].string );
        if( initfunc ) {
            if( initfunc( i ) == FALSE ){
				CHAR_chara[i].use = FALSE;
                ret = FALSE;
            }
        }
        if( ret ){
            CHAR_chara[i].use = TRUE;
            CHAR_constructFunctable( i );
            if( i + 1 >= initCharCounter[mode].endcnt ) {
                initCharCounter[mode].cnt
                    = initCharCounter[mode].startcnt;
            }else {
                initCharCounter[mode].cnt = i+1;
			}
        	CHAR_chara[i].CharMakeSequenceNumber = CharMakeSequenceNumber++;
			if( CharMakeSequenceNumber == 0xffffffff) CharMakeSequenceNumber = 0;
        }
    }else{
        fprint( "Error: Char full\n" );
	}
    return ret ? i: -1;
}

void CHAR_removeHaveItem( Char* ch )
{
    int     i;
    if( ch == NULL )return;
    for( i=0 ; i<CHAR_MAXITEMHAVE ; i++ ) {
		int itemindex = ch->indexOfExistItems[i];
		ch->indexOfExistItems[i] = -1;
        ITEM_endExistItemsOne( itemindex );
	}
}

void CHAR_removeHavePoolItem( Char* ch )
{
    int     i;
    if( ch == NULL )return;
    for( i=0 ; i<CHAR_MAXPOOLITEMHAVE ; i++ ) {
		int itemindex = ch->indexOfExistPoolItems[i];
		ch->indexOfExistPoolItems[i] = -1;
        ITEM_endExistItemsOne( itemindex );
	}
}

void CHAR_endCharData( Char* ch )
{
    if( ch == NULL ){
		return;
	}
    CHAR_removeHaveItem( ch );
	CHAR_removeHavePoolItem( ch);

#ifdef _CHAR_POOLITEM
//	CHAR_removeHaveDepotItem( ch );
#endif
#ifdef _CHAR_POOLPET
//	CHAR_removeHaveDepotPet( ch );
#endif

    ch->use = FALSE;
}

void CHAR_endCharOneArray( int index )
{
    Char*   ch = NULL;
	if( !CHAR_CHECKINDEX( index) ) return;
	ch = CHAR_getCharPointer(index);

    if( ch == NULL ){
		print( "CHAR_endCharOneArray err ch == NULL :%d\n", index);
		return;
	}
    CHAR_endCharData( ch );
}
static char CHAR_dataString[STRINGBUFSIZ*16*2];
BOOL CHAR_checksetdata( void )
{
    int     i;
    char*   strings[CHAR_DATAINTNUM + CHAR_DATACHARNUM];
    int     stringnum=0;
    for(i = 0; i < CHAR_DATAINTNUM ; i ++ ){
        if( CHAR_setintdata[i][0] != '#' )
            strings[stringnum++] = CHAR_setintdata[i];
    }
    for( i = 0 ; i < CHAR_DATACHARNUM ; i ++ ){
        if( CHAR_setchardata[i][0] != '#' )
            strings[stringnum++] = CHAR_setchardata[i];
    }
    if( ! checkStringsUnique( strings, stringnum , 1 ) ){
        fprint( "set????data is overlapped.\nIt is not allowed\n");
        return FALSE;
    }
    return TRUE;
}

#define FLGRESERVESTRING   "flg"
#define ITEMRESERVESTRING   "item"
#define POOLITEMRESERVESTRING   "poolitem"
#define SKILLRESERVESTRING  "skill"
#define TITLERESERVESTRING  "title"
#define ADDRESSBOOKRESERVESTRING  "adr"
#define	PETSERVERSTRING		"pet"
#define PETITEMRESERVESTRING   "pitem"
#define	PETSKILLSERVERSTRING	"psk"
#define	POOLPETSERVERSTRING		"poolpet"
#define ITEMPOOLRESERVESTRING   "itempool"

#define	DATAENDCHECKPOINT		"DATAEND"




#ifdef _CHAR_POOLITEM
#define DEPOTITEMRESERVESTRING   "Depotitem"
#endif
#ifdef _CHAR_POOLPET
#define DEPOTPETRESERVESTRING   "Depotpet"
#endif

char* CHAR_makeStringFromCharData( Char* one )
{
    int     i;
	int		petnum;
	int     strlength=0;

    if (!one) return NULL;

	memset( CHAR_dataString, 0, sizeof(CHAR_dataString));
    for( i = 0 ; i < CHAR_DATAINTNUM ; i ++ ){
        char    linedata[256];
        snprintf( linedata , sizeof(linedata),
                  "%s=%d" CHAR_DELIMITER,
                  CHAR_setintdata[i],
                  one->data[i] );
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
		}
    }
    for( i = 0 ; i < CHAR_DATACHARNUM ; i ++ ){
        char    linedata[256];
        char    escapebuffer[256];
        snprintf( linedata , sizeof(linedata),