char_base.c.bak

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

    CHAR_chara[index].data[element] = data;
    return buf;
}

#ifdef _FIX_SETWORKINT
INLINE int _CHAR_getWorkInt( char *file, int line, int index ,CHAR_WORKDATAINT element)
#else
INLINE int CHAR_getWorkInt( int index ,CHAR_WORKDATAINT element)
#endif
{
	if( CHAR_WORKBATTLEMODE > element || element >= CHAR_WORKDATAINTNUM )	{
		print("err Get WorkInt element=%d :: file:%s %d!\n", element, file, line);
		return -1;
	}
    return CHAR_chara[index].workint[element];
}

#ifdef _FIX_SETWORKINT
INLINE int _CHAR_setWorkInt( char *file, int line, int index ,CHAR_WORKDATAINT element, int data)
#else
INLINE int CHAR_setWorkInt( int index ,CHAR_WORKDATAINT element, int data)
#endif
{
    int buf;
	if( !CHAR_CHECKINDEX( index) )	{
		print( "err Set WorkInt index:%d:%s[%d].\n", index, file, line);
		return -1;
	}
	if( CHAR_WORKBATTLEMODE > element || element >= CHAR_WORKDATAINTNUM )	{
#ifdef _FIX_SETWORKINT
		print("err Set WorkInt element=%d.%s:%s[%d]!\n", element, CHAR_getChar( index, CHAR_CDKEY), file, line);
#else
		print("err Set WorkInt element=%d.%s!\n", element, CHAR_getChar( index, CHAR_CDKEY) );
#endif
		return -1;
	}

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

INLINE char* _CHAR_getChar( char *file, int line, int index ,CHAR_DATACHAR element )
{
    if(!CHAR_CHECKINDEX(index)) {
		print( "err _CHAR_getChar %s:%d index[%d] !!\n", file, line, index);
    	return NULL;
    }
    if(!CHAR_CHECKCHARDATAINDEX(element)) {
		print( "err _CHAR_getChar %s:%d element[%d] !!\n", file, line, element);
    	return NULL;
	}
    return CHAR_chara[index].string[element].string;
}

INLINE BOOL _CHAR_setChar( char *file, int line, int index ,CHAR_DATACHAR element, char* new )
{
    if(!CHAR_CHECKINDEX(index)) {
		print( "err _CHAR_setChar %s:%d !\n", file, line);
    	return FALSE;
    }
    if(!CHAR_CHECKCHARDATAINDEX(element)) {
		print( "err _CHAR_setChar %s:%d !\n", file, line);
    	return FALSE;
    }
    strcpysafe( CHAR_chara[index].string[element].string,
                sizeof(CHAR_chara[index].string[element].string),
                new );
    return TRUE;
}

static INLINE char* CHAR_getCharfunctable( int index ,CHAR_FUNCTABLE element )
{
    if(!CHAR_CHECKINDEX(index))return NULL;
    if(!CHAR_CHECKCHARFUNCTABLEINDEX(element))return NULL;


    return CHAR_chara[index].charfunctable[element].string;
}

INLINE char* _CHAR_getWorkChar( char *file, int line, int index ,CHAR_WORKDATACHAR element )
{
    if(!CHAR_CHECKINDEX(index)) {
		print( "err %s:%d \n", file, line);
    	return NULL;
    }
    if(!CHAR_CHECKCHARWORKDATAINDEX(element)) {
		print( "err %s:%d \n", file, line);
    	return NULL;
    }
    return CHAR_chara[index].workchar[element].string;
}

INLINE BOOL _CHAR_setWorkChar( char *file, int line, int index ,CHAR_WORKDATACHAR element,
                              char* new )
{
    if(!CHAR_CHECKINDEX(index)) {
		print( "err %s:%d \n", file, line);
    	return FALSE;
    }
    if(!CHAR_CHECKCHARWORKDATAINDEX(element)) {
		print( "err %s:%d \n", file, line);
    	return FALSE;
    }
    strcpysafe( CHAR_chara[index].workchar[element].string,
                sizeof(CHAR_chara[index].workchar[element].string),
                new );
    return TRUE;
}

static char CHAR_flgbitmaskpattern[]=
{
    0x01,
    0x02,
    0x04,
    0x08,
    0x10,
    0x20,
    0x40,
    0x80,
};

INLINE BOOL _CHAR_getFlg( char *file, int line, int index ,CHAR_DATAFLG element )
{
    int     elementnum;
    int     bitnum;
    if(!CHAR_CHECKINDEX(index)) {
		//print( "err %s:%d from %s:%d \n", __FILE__, __LINE__,file, line);
    	return FALSE;
    }
    if(!CHAR_CHECKFLGDATAINDEX(element)) {
		//print( "err %s:%d from %s:%d \n", __FILE__, __LINE__,file, line);
	    return FALSE;
	}
    elementnum = element / (sizeof( char )*8);
    bitnum = element % (sizeof( char )*8);


    if( CHAR_chara[index].flg[elementnum]
        & CHAR_flgbitmaskpattern[bitnum])
        return TRUE;
    else
        return FALSE;

}

INLINE char _CHAR_setFlg( char *file, int line, int index , CHAR_DATACHAR element, int newdata )
{
    int buf;
    int elementnum;
    int bitnum;
    char    bitpattern;

    if(!CHAR_CHECKINDEX(index)) {
		print( "err %s:%d \n", file, line);
    	return FALSE;
    }
    if(!CHAR_CHECKFLGDATAINDEX(element)) {
		print( "err %s:%d \n", file, line);
    	return FALSE;
	}
    elementnum = element / (sizeof( char )*8);
    bitnum = element % (sizeof( char )*8);

    /*  樯及袄毛转      */
    buf = CHAR_chara[index].flg[elementnum]
        & CHAR_flgbitmaskpattern[bitnum];

    if( newdata != 0 ){
        bitpattern = CHAR_flgbitmaskpattern[bitnum];
        CHAR_chara[index].flg[elementnum] |= bitpattern;

    }else{
        bitpattern = ~CHAR_flgbitmaskpattern[bitnum];
        CHAR_chara[index].flg[elementnum] &= bitpattern;
    }

    if( buf )return 1;
    else     return 0;
}

INLINE int _CHAR_getItemIndex( char *file, int line, int charaindex ,int ti)
{
    if( !CHAR_CHECKINDEX( charaindex)) {
		print( "err %s:%d from %s:%d\n", __FILE__, __LINE__,file, line);
    	return -1;
    }
    if( !CHAR_CHECKITEMINDEX( charaindex, ti) ){
		print( "err %s:%d from %s:%d \n", __FILE__, __LINE__,file, line);
    	return -1;
    }
    return CHAR_chara[charaindex].indexOfExistItems[ti];
}

INLINE int _CHAR_setItemIndex( char *file, int line, int index ,int iindex,int id )
{
    int buf;
    if( !CHAR_CHECKINDEX(index)) {
		print( "err %s:%d \n", file, line);
    	return -1;
    }
    if( CHAR_MAXITEMHAVE <= iindex || iindex < 0 ) {
		print( "err %s:%d \n", file, line);
    	return -1;
    }

// CoolFish: 2001/10/12
#ifdef _UNIQUE_P_I    
	if ( (id != -1)  && (ITEM_getChar(id, ITEM_UNIQUECODE) != NULL) )  // shan add hjj
    	ITEM_setItemUniCode(id);
#endif

#ifdef _ITEM_TIME_LIMIT
	if( (id != -1) && ITEM_getWorkInt( id, ITEM_WORKTIMELIMIT) == -1 ){
		char    *arg, *p=NULL, tmp[16]="";	
		long    iTmp;
		time_t	iTime;
		
    	time(&iTime);
    	iTmp = iTime;
		arg = ITEM_getChar( id, ITEM_ARGUMENT);
		if(arg && (p=strstr( arg, "Time")) != NULL ){
			//andy_log
			print("%s setTime arg:%s \n", ITEM_getChar( id, ITEM_NAME), arg);
			strcpy( tmp, (p+4));				
			iTmp += atoi(tmp)*60;
			ITEM_setWorkInt( id, ITEM_WORKTIMELIMIT, iTmp);
		}
	}
#endif
    buf = CHAR_chara[index].indexOfExistItems[iindex];
    CHAR_chara[index].indexOfExistItems[iindex] = id;
    return buf;
}
INLINE int _CHAR_getPoolItemIndex( char *file, int line, int index ,int iindex)
{
    if( !CHAR_CHECKINDEX(index)) {
		print( "err %s:%d from %s:%d\n", __FILE__, __LINE__,file, line);
    	return -1;
    }
    if( CHAR_MAXPOOLITEMHAVE <= iindex || iindex < 0 ) {
		print( "err %s:%d from %s:%d \n", __FILE__, __LINE__,file, line);
    	return -1;
    }
    return CHAR_chara[index].indexOfExistPoolItems[iindex];
}
INLINE int _CHAR_setPoolItemIndex( char *file, int line, int index ,int iindex,int id )
{
    int buf;
    if( !CHAR_CHECKINDEX(index)) {
		print( "err %s:%d \n", file, line);
    	return -1;
    }
    if( CHAR_MAXPOOLITEMHAVE <= iindex || iindex < 0 ) {
		print( "err %s:%d \n", file, line);
    	return -1;
    }
    buf = CHAR_chara[index].indexOfExistPoolItems[iindex];
    CHAR_chara[index].indexOfExistPoolItems[iindex] = id;
    return buf;
}

INLINE BOOL CHAR_setAddressbookEntry( int index , int aindex ,
                                 ADDRESSBOOK_entry *a )
{
    if( !CHAR_CHECKINDEX(index))return FALSE;
    if( !CHAR_CHECKADDRESSBOOKINDEX( aindex ))return FALSE;

    memcpy( & CHAR_chara[index].addressBook[aindex] , a ,
            sizeof(ADDRESSBOOK_entry ));

    return TRUE;
}

INLINE ADDRESSBOOK_entry* CHAR_getAddressbookEntry( int index ,
                                                    int aindex)
{
    if( !CHAR_CHECKINDEX(index))return (ADDRESSBOOK_entry*)NULL;
    if( !CHAR_CHECKADDRESSBOOKINDEX( aindex ))
        return (ADDRESSBOOK_entry*) NULL;

    return &CHAR_chara[index].addressBook[aindex];
}

INLINE Char* CHAR_getCharPointer( int index )
{
    if( !CHAR_CHECKINDEX(index) )return NULL;
    return &CHAR_chara[index];
}

INLINE int CHAR_getCharNum( void )
{
    return CHAR_charanum;
}

INLINE int CHAR_getPlayerMaxNum( void )
{
    return CHAR_playernum;
}

INLINE int CHAR_getPetMaxNum( void )
{
    return CHAR_petnum;
}
INLINE int CHAR_getOthersMaxNum( void )
{
    return CHAR_othersnum;
}

INLINE BOOL CHAR_getCharUse( int index )
{
    if( !CHAR_CHECKINDEX(index))
    	return FALSE;
    return CHAR_chara[index].use;
}

INLINE CHAR_HaveSkill* CHAR_getCharHaveSkill( int index,int sindex )
{
    if( !CHAR_CHECKINDEX(index))return NULL;
    if( !CHAR_CHECKSKILLINDEX(sindex))return NULL;
	return &CHAR_chara[index].haveSkill[sindex];
}
//------------------------------------------------------------------------
//人物index  技能位置  索引
INLINE int _CHAR_getIntPSkill( char *file, int line, int index, int skillti, SKILL_DATAINT ti)
{
    if( !CHAR_CHECKINDEX( index) ) return -1;
    if( !CHAR_CHECKSKILLINDEX( skillti) )  return -1;
	if( ti >= SKILL_DATAINTNUM || ti < 0 ){
		print(" getIntPSkill()  SKILL_DATAINT (%d) err -%s:%d!!\n", ti , file, line);
		return -1;
	}
	if( CHAR_chara[index].haveSkill[skillti].skill.data[ti] <= 0 ) return -1;
	return CHAR_chara[index].haveSkill[skillti].skill.data[ti];
}
//人物index  技能位置  索引 欲设定值
INLINE void _CHAR_setIntPSkill( char *file, int line, int index, int skillti, SKILL_DATAINT ti, int data)
{
    if( !CHAR_CHECKINDEX( index) ) return;
    if( !CHAR_CHECKSKILLINDEX( skillti) )  return;
	if( ti >= SKILL_DATAINTNUM || ti < 0 ){
		print(" getIntPSkill()  SKILL_DATAINT (%d) err -%s:%d!!\n", ti , file, line);
		return;
	}
//	if( CHAR_chara[index].haveSkill[sindex].use > 0 )
	CHAR_chara[index].haveSkill[skillti].skill.data[ti] = data;
}
//------------------------------------------------------------------------

#ifdef _PROFESSION_SKILL			// WON ADD 人物职业技能
int CHAR_getCharSkill( int index,int sindex )
{
	CHAR_HaveSkill* hskill;
	
	hskill = CHAR_getCharHaveSkill( index, sindex );

	if(hskill != NULL)
		return SKILL_getInt( &hskill->skill, SKILL_IDENTITY);
	else
		return -1;

}

int CHAR_setCharSkill( int index,int sindex, int new )
{
	CHAR_HaveSkill* hskill;

    if( !CHAR_CHECKINDEX(index))	return -1;
    if( !CHAR_CHECKSKILLINDEX(sindex))	return -1;
	
	hskill = CHAR_getCharHaveSkill( index, sindex );
	SKILL_setInt( &hskill->skill, SKILL_IDENTITY, new);
	return TRUE;
}
#endif

INLINE int CHAR_getCharHaveTitle( int charaindex,int tindex )
{
    if( !CHAR_CHECKINDEX(charaindex))return 0;
    if( !CHAR_CHECKTITLEINDEX(tindex))return 0;
    return CHAR_chara[charaindex].indexOfHaveTitle[tindex];
}

INLINE int CHAR_setCharHaveTitle( int charaindex,int tindex, int new )
{
    int ret;
    if( !CHAR_CHECKINDEX(charaindex))return 0;
    if( !CHAR_CHECKTITLEINDEX(tindex))return 0;
	if( new != -1 )
		if( TITLE_getTitleIndex( new) == -1 ) return 0;
    ret = CHAR_getCharHaveTitle( charaindex,tindex);
    CHAR_chara[charaindex].indexOfHaveTitle[tindex] = new;
    return ret;
}

INLINE int CHAR_getCharPet( int charaindex,int petindex )
{
    if( !CHAR_CHECKINDEX(charaindex))return -1;
    if( !CHAR_CHECKPETINDEX(petindex))return -1;
    return CHAR_chara[charaindex].unionTable.indexOfPet[petindex];
}

INLINE int CHAR_setCharPet( int charaindex,int petindex, int new )
{
    int ret;
    if( !CHAR_CHECKINDEX(charaindex))return -1;
    if( !CHAR_CHECKPETINDEX(petindex))return -1;
    ret = CHAR_getCharPet( charaindex,petindex);

// CoolFish: 2001/10/12
#ifdef _UNIQUE_P_I
    if (new != -1)
	CHAR_setPetUniCode(new);
#endif

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

INLINE int CHAR_getCharPoolPet( int charaindex,int petindex )
{
    if( !CHAR_CHECKINDEX(charaindex))return -1;
    if( !CHAR_CHECKPOOLPETINDEX(petindex))return -1;
    return CHAR_chara[charaindex].indexOfPoolPet[petindex];