enemy.c

石器时代2.0完整版源代码.已经加入新功能. 在REDHAT9下GCC3.4编译成功.

		int	aaa = 0;
		int	r;
		r = RAND( 0, r_max);
		for( i = 0; i < found-1; i ++ ) {
			aaa += wr[i];
			if( wr[i] != 0 && r < aaa ) break;
		}
		r = i;

		groupid = ENCOUNT_getGroupIdFromArray( array, work[r]);
		g_array = GROUP_getGroupArray( groupid);
    }
    for( i = 0 ; i < ENEMY_INDEXTABLEMAXSIZE; i ++ ) {
        work[i] = -1;
				wr[i] = -1;
    }
		createenemynum = 0;
		found = 0;
		r_max = 0;
    for( i = ENEMY_ID1; i < CREATEPROB1; i ++ ) {
		int newarray, enemywork;
		e_array = ENEMY_getEnemyArrayFromIndex( g_array, i - ENEMY_ID1 );

#ifdef _ADD_ENCOUNT           // WON ADD 增加敌遭遇触发修件
		{	
		int char_event_now = -1, char_event_end = -1;
		if(ENCOUNT_table[array].event_now != -1){
			char_event_now = ENCOUNT_table[array].event_now;
		}
		else if(ENCOUNT_table[array].event_end != -1){
			char_event_end = ENCOUNT_table[array].event_end;
		}
		if( (char_event_now > 0) || ( char_event_end > 0 ) ) {
			if( (NPC_NowEventCheckFlg( charaindex, char_event_now) == TRUE ) ||
				(NPC_EventCheckFlg( charaindex, char_event_end) == TRUE )    ){
					
				e_array = ENEMY_getEnemyArrayFromIndex( 
					   GROUP_getGroupArray( ENCOUNT_table[array].enemy_group ),i - ENEMY_ID1 );
			}
		}	
		}
#endif
		enemywork = ENEMY_getInt( e_array, ENEMY_ID );
		if( ENEMY_RandomEnemyArray( enemywork, &newarray ) ){
			e_array = newarray;
		}

		if( e_array != -1 ) {
            work[found] = e_array;
            wr[found] = GROUP_getInt( g_array, i + (CREATEPROB1 - ENEMY_ID1));
            r_max += wr[found];
            found ++;
            createenemynum += ENEMY_getInt( e_array, ENEMY_CREATEMAXNUM);
        }
    }
    r_max --;

	if( found <= 0 ) return NULL;
    enemyentrymax= min( enemyentrymax, createenemynum );
	entrymax = RAND( 1, enemyentrymax);
	bigcnt = 0;
    for( i = 0,loopcounter = 0; i < entrymax && loopcounter < 100; loopcounter ++) {
		int	cnt;
    	int	j,r;
		int	aaa = 0;
		int		et_array;
		int	k,samecount;
		r = RAND( 0, r_max);
		for( j = 0; j < found-1; j ++ ) {
			aaa += wr[j];
			if( wr[j] != 0 && r < aaa ) break;
		}
		r = j;
		cnt = 0;
		for( j = 0; j < ENEMY_INDEXTABLEMAXSIZE && ENEMY_indextable[j] != -1; j ++ ) {
			if( ENEMY_indextable[j] == work[r] ) cnt ++;
		}
		samecount = 0;
		for( k = 0; k < found; k ++ ) {
			if( work[r] == work[k] ) samecount ++;
		}
    	if( cnt >= ENEMY_getInt( work[r], ENEMY_CREATEMAXNUM) * samecount ) {
    		continue;
    	}

		et_array = ENEMYTEMP_getEnemyTempArray( work[r]);
		if( ENEMYTEMP_CHECKINDEX( et_array)) {
			if( ENEMYTEMP_getInt( et_array, E_T_SIZE) == E_T_SIZE_BIG ) {
				if( bigcnt >= 5 ) {
					entrymax --;
					continue;
				}
				if( i > 4 ) {
					int	target_et_array;
					int	flg = FALSE;
					for( j = 0; j < 5; j ++ ) {
						if( !ENEMY_CHECKINDEX( ENEMY_indextable[j])) break;

						target_et_array = ENEMYTEMP_getEnemyTempArray(
														ENEMY_indextable[j]);
						if( !ENEMYTEMP_CHECKINDEX( target_et_array)) break;
						if( ENEMYTEMP_getInt( target_et_array, E_T_SIZE) == E_T_SIZE_NORMAL ){
							flg = TRUE;
							break;
						}
					}
					if( !flg) continue;
					ENEMY_indextable[i] = ENEMY_indextable[j];
					ENEMY_indextable[j] = work[r];
				}
				else {
					ENEMY_indextable[i] = work[r];
				}
				bigcnt ++;
			}else {
				ENEMY_indextable[i] = work[r];
    		}

			i++;
    	}
    }
    return found > 0 ? ENEMY_indextable : NULL;
}
int ENEMY_createPetFromEnemyIndex( int charaindex, int array)
{
    Char    CharNew;
    int newindex;
    int     *p;
    int		tp[E_T_DATAINTNUM];
    int		tarray, i;
    int     havepetelement;
	int		level;
	int		enemyrank;
    if( !ENEMY_CHECKINDEX( array)) return -1;
    havepetelement = CHAR_getCharPetElement( charaindex);
    if( havepetelement < 0 ) return -1;

    p = ENEMY_enemy[array].intdata;
	tarray = ENEMYTEMP_getEnemyTempArray( array);
	if( !ENEMYTEMP_CHECKINDEX( tarray)) return -1;
//    tp = ENEMYTEMP_enemy[tarray].intdata;
	for( i = 0; i < E_T_DATAINTNUM; i ++ ){
	    tp[i] = ENEMYTEMP_enemy[tarray].intdata[i];
	}
    memset( &CharNew, 0, sizeof( Char ) );
    if( !CHAR_getDefaultChar( &CharNew,31010 ) )return -1;
    CharNew.data[CHAR_BASEBASEIMAGENUMBER]
        = CharNew.data[CHAR_BASEIMAGENUMBER] = *(tp+E_T_IMGNUMBER);
    CharNew.data[CHAR_WHICHTYPE] = CHAR_TYPEPET;
	level = RAND( (*(p + ENEMY_LV_MIN)), ( *(p+ ENEMY_LV_MAX)));

#define		E_PAR( a)		(*(p + (a)))
#define		ET_PAR( a)		(*(tp + (a)))
#if 1
#define		PARAM_CAL( l) 	(( level -1)*ET_PAR( E_T_LVUPPOINT)+ ET_PAR(E_T_INITNUM)) * ET_PAR( (l))
#else
#define		PARAM_CAL( l)	( (E_PAR(ENEMY_LV) -1)*ET_PAR( E_T_LVUPPOINT)+ ET_PAR(E_T_INITNUM))	* ET_PAR( (l))
#endif
	tp[E_T_BASEVITAL] += RAND( 0, 4 ) - 2;
	tp[E_T_BASESTR] += RAND( 0, 4 ) - 2;
	tp[E_T_BASETGH] += RAND( 0, 4 ) - 2;
	tp[E_T_BASEDEX] += RAND( 0, 4 ) - 2;
    CharNew.data[CHAR_ALLOCPOINT]
    = ( tp[E_T_BASEVITAL] << 24 )
    + ( tp[E_T_BASESTR] << 16 )
    + ( tp[E_T_BASETGH] << 8 )
    + ( tp[E_T_BASEDEX] << 0 );

	for( i = 0; i < 10; i ++ ){
		int work = RAND( 0, 3 );
		if( work == 0 )tp[E_T_BASEVITAL]++;
		if( work == 1 )tp[E_T_BASESTR]++;
		if( work == 2 )tp[E_T_BASETGH]++;
		if( work == 3 )tp[E_T_BASEDEX]++;
	}
    /* 由仿丢□正本永玄 */
    CharNew.data[CHAR_VITAL]    = PARAM_CAL(E_T_BASEVITAL);
    CharNew.data[CHAR_STR]      = PARAM_CAL(E_T_BASESTR);
    CharNew.data[CHAR_TOUGH]    = PARAM_CAL(E_T_BASETGH);
    CharNew.data[CHAR_DEX]      = PARAM_CAL(E_T_BASEDEX);

    CharNew.data[CHAR_FIREAT]   = *(tp+ E_T_FIREAT);
    CharNew.data[CHAR_WATERAT]  = *(tp+ E_T_WATERAT);
    CharNew.data[CHAR_EARTHAT]  = *(tp+ E_T_EARTHAT);
    CharNew.data[CHAR_WINDAT]   = *(tp+ E_T_WINDAT);

    CharNew.data[CHAR_SLOT]     = *(tp+ E_T_SLOT);
    CharNew.data[CHAR_MODAI]    = *(tp+ E_T_MODAI);
    CharNew.data[CHAR_VARIABLEAI]    = 0;
		CharNew.data[CHAR_LV]       = level;
	//CharNew.data[CHAR_LV]       = *(p+ ENEMY_LV);
    CharNew.data[CHAR_POISON]   = *(tp+ E_T_POISON);
    CharNew.data[CHAR_PARALYSIS]= *(tp+ E_T_PARALYSIS);
    CharNew.data[CHAR_SLEEP]	= *(tp+ E_T_SLEEP);
    CharNew.data[CHAR_STONE]	= *(tp+ E_T_STONE);
    CharNew.data[CHAR_DRUNK]	= *(tp+ E_T_DRUNK);
    CharNew.data[CHAR_CONFUSION]= *(tp+ E_T_CONFUSION);
    CharNew.data[CHAR_RARE]     = *(tp+ E_T_RARE);
	CharNew.data[CHAR_PETID]	= *(tp + E_T_TEMPNO);
	CharNew.data[CHAR_CRITIAL]	= *(tp + E_T_CRITICAL);
	CharNew.data[CHAR_COUNTER]	= *(tp + E_T_COUNTER);
    // Arminius 8.6 limit lv
    CharNew.data[CHAR_LIMITLEVEL]	= *(tp + E_T_LIMITLEVEL);
	CharNew.data[CHAR_PETMAILEFFECT] = RAND(0, PETMAIL_EFFECTMAX);
	for( i = 0; i < CHAR_MAXPETSKILLHAVE; i ++ ) {
		CharNew.unionTable.indexOfPetskill[i] = *(tp + E_T_PETSKILL1 + i);
	}
	enemyrank = ENEMY_getRank( array, tarray );
	CharNew.data[CHAR_PETRANK]	= enemyrank;
#undef	E_PAR
#undef	ET_PAR
#undef	PARAM_CAL
    strcpysafe( CharNew.string[CHAR_NAME].string,
                sizeof(CharNew.string[CHAR_NAME].string),
                (char *)ENEMYTEMP_enemy[tarray].chardata[E_T_NAME].string );
    newindex = PET_initCharOneArray( &CharNew );
    if( newindex < 0 ){
        return -1;
    }
    CHAR_complianceParameter( newindex );
	  CHAR_setInt( newindex, CHAR_HP, CHAR_getWorkInt( newindex, CHAR_WORKMAXHP));
    CHAR_setWorkInt( newindex, CHAR_WORKPLAYERINDEX, charaindex);
    CHAR_setCharPet( charaindex, havepetelement, newindex);
	  CHAR_setChar( newindex, CHAR_OWNERCDKEY,
		CHAR_getChar( charaindex, CHAR_CDKEY));
	  CHAR_setChar( newindex, CHAR_OWNERCHARANAME,
		CHAR_getChar( charaindex, CHAR_NAME));
    return newindex;
}

#ifdef _TEST_DROPITEMS
int ENEMY_TEST_createPetIndex( int array)
{
    Char    CharNew;
    int newindex;
    int     *p;
    int		tp[E_T_DATAINTNUM];
    int		tarray, i;
    //int     havepetelement;
	int		level;
	int		enemyrank;
    if( !ENEMY_CHECKINDEX( array)) return -1;

    //havepetelement = CHAR_getCharPetElement( charaindex);
    //if( havepetelement < 0 ) return -1;
    p = ENEMY_enemy[array].intdata;
	tarray = ENEMYTEMP_getEnemyTempArray( array);
	if( !ENEMYTEMP_CHECKINDEX( tarray)) return -1;
	for( i = 0; i < E_T_DATAINTNUM; i ++ ){
	    tp[i] = ENEMYTEMP_enemy[tarray].intdata[i];
	}
    memset( &CharNew, 0, sizeof( Char ) );
    if( !CHAR_getDefaultChar( &CharNew,31010 ) )return -1;
    CharNew.data[CHAR_BASEBASEIMAGENUMBER]
        = CharNew.data[CHAR_BASEIMAGENUMBER] = *(tp+E_T_IMGNUMBER);
    CharNew.data[CHAR_WHICHTYPE] = CHAR_TYPEPET;
	level = RAND( (*(p + ENEMY_LV_MIN)), ( *(p+ ENEMY_LV_MAX)));

#define		E_PAR( a)		(*(p + (a)))
#define		ET_PAR( a)		(*(tp + (a)))

#if 1
#define		PARAM_CAL( l) 	(( level -1)*ET_PAR( E_T_LVUPPOINT)+ ET_PAR(E_T_INITNUM)) * ET_PAR( (l))
#else
#define		PARAM_CAL( l)	( (E_PAR(ENEMY_LV) -1)*ET_PAR( E_T_LVUPPOINT)+ ET_PAR(E_T_INITNUM))	* ET_PAR( (l))
#endif
	tp[E_T_BASEVITAL] += RAND( 0, 4 ) - 2;
	tp[E_T_BASESTR] += RAND( 0, 4 ) - 2;
	tp[E_T_BASETGH] += RAND( 0, 4 ) - 2;
	tp[E_T_BASEDEX] += RAND( 0, 4 ) - 2;
    CharNew.data[CHAR_ALLOCPOINT]
    = ( tp[E_T_BASEVITAL] << 24 )
    + ( tp[E_T_BASESTR] << 16 )
    + ( tp[E_T_BASETGH] << 8 )
    + ( tp[E_T_BASEDEX] << 0 );
	for( i = 0; i < 10; i ++ ){
		int work = RAND( 0, 3 );
		if( work == 0 )tp[E_T_BASEVITAL]++;
		if( work == 1 )tp[E_T_BASESTR]++;
		if( work == 2 )tp[E_T_BASETGH]++;
		if( work == 3 )tp[E_T_BASEDEX]++;
	}
    CharNew.data[CHAR_VITAL]    = PARAM_CAL(E_T_BASEVITAL);
    CharNew.data[CHAR_STR]      = PARAM_CAL(E_T_BASESTR);
    CharNew.data[CHAR_TOUGH]    = PARAM_CAL(E_T_BASETGH);
    CharNew.data[CHAR_DEX]      = PARAM_CAL(E_T_BASEDEX);
    CharNew.data[CHAR_FIREAT]   = *(tp+ E_T_FIREAT);
    CharNew.data[CHAR_WATERAT]  = *(tp+ E_T_WATERAT);
    CharNew.data[CHAR_EARTHAT]  = *(tp+ E_T_EARTHAT);
    CharNew.data[CHAR_WINDAT]   = *(tp+ E_T_WINDAT);

    CharNew.data[CHAR_SLOT]     = *(tp+ E_T_SLOT);
    CharNew.data[CHAR_MODAI]    = *(tp+ E_T_MODAI);
    CharNew.data[CHAR_VARIABLEAI]    = 0;
	CharNew.data[CHAR_LV]       = level;
    CharNew.data[CHAR_POISON]   = *(tp+ E_T_POISON);
    CharNew.data[CHAR_PARALYSIS]= *(tp+ E_T_PARALYSIS);
    CharNew.data[CHAR_SLEEP]	= *(tp+ E_T_SLEEP);
    CharNew.data[CHAR_STONE]	= *(tp+ E_T_STONE);
    CharNew.data[CHAR_DRUNK]	= *(tp+ E_T_DRUNK);
    CharNew.data[CHAR_CONFUSION]= *(tp+ E_T_CONFUSION);
    CharNew.data[CHAR_RARE]     = *(tp+ E_T_RARE);
	CharNew.data[CHAR_PETID]	= *(tp + E_T_TEMPNO);
	CharNew.data[CHAR_CRITIAL]	= *(tp + E_T_CRITICAL);
	CharNew.data[CHAR_COUNTER]	= *(tp + E_T_COUNTER);
    // Arminius 8.6 limit lv
    CharNew.data[CHAR_LIMITLEVEL]	= *(tp + E_T_LIMITLEVEL);
	CharNew.data[CHAR_PETMAILEFFECT] = RAND(0, PETMAIL_EFFECTMAX);
	for( i = 0; i < CHAR_MAXPETSKILLHAVE; i ++ ) {
		CharNew.unionTable.indexOfPetskill[i] = *(tp + E_T_PETSKILL1 + i);
	}
	enemyrank = ENEMY_getRank( array, tarray );
	CharNew.data[CHAR_PETRANK]	= enemyrank;
#undef	E_PAR
#undef	ET_PAR
#undef	PARAM_CAL
    strcpysafe( CharNew.string[CHAR_NAME].string,
                sizeof(CharNew.string[CHAR_NAME].string),
                (char *)ENEMYTEMP_enemy[tarray].chardata[E_T_NAME].string );
    newindex = PET_initCharOneArray( &CharNew );
    if( newindex < 0 ){
        return -1;
    }
    CHAR_complianceParameter( newindex );
	CHAR_setInt( newindex, CHAR_HP, CHAR_getWorkInt( newindex, CHAR_WORKMAXHP));
//  CHAR_setWorkInt( newindex, CHAR_WORKPLAYERINDEX, charaindex);
//  CHAR_setCharPet( charaindex, havepetelement, newindex);
//	CHAR_setChar( newindex, CHAR_OWNERCDKEY,
//	CHAR_getChar( charaindex, CHAR_CDKEY));
//	CHAR_setChar( newindex, CHAR_OWNERCHARANAME,
//	CHAR_getChar( charaindex, CHAR_NAME));
    return newindex;
}
#endif

#ifdef _PET_TRANS
int GetNewPet( int toindex , int petindex, int array, int *work)
{
    int     *p;
    int		tp[E_T_DATAINTNUM];
    int		tarray, i;
	int		level, workrank, petrank=0;
	int		LevelUpPoint;

	struct 	{
    	int		num;
    	float	rank;
    }ranktbl[] = {
    	{ 130, 2.5},
    	{ 100, 2.0},
    	{ 95, 1.5},
    	{ 85, 1.0},
    	{ 80, 0.5},
    	{ 0, 0.0},
    };

    if( !ENEMY_CHECKINDEX( array))
		return -1;
	p = ENEMY_getIntdata( array);
	if( p == NULL )	{
		print("\n p = NULL" );
		return -1;
	}
	tarray = ENEMYTEMP_getEnemyTempArray( array);
	if( !ENEMYTEMP_CHECKINDEX( tarray))
		return -1;
	for( i = 0; i < E_T_DATAINTNUM; i ++ ){
		tp[i] = ENEMYTEMP_getInt( tarray, i);
	}
	level = 1;
#define RAND(x,y)   ((x-1)+1+ (int)( (double)(y-(x-1))*rand()/(RAND_MAX+1.0)) )
#define		E_PAR( a)		(*(p + (a)))
#define		ET_PAR( a)		(*(tp + (a)))
#define		PARAM_CAL( l) 	( ( level -1) * ET_PAR( E_T_LVUPPOINT) + ET_PAR( E_T_INITNUM) )
	work[0] += ( RAND(0,4) - 2 );
	work[1] += ( RAND(0,4) - 2 );
	work[2] += ( RAND(0,4) - 2 );
	work[3] += ( RAND(0,4) - 2 );

	LevelUpPoint = ( work[0] << 24 )
		+ (work[1] << 16)
		+ (work[2] << 8 )
		+ (work[3] << 0 );
	CHAR_setInt( petindex, CHAR_ALLOCPOINT, LevelUpPoint);
	workrank = work[0]+work[1]+work[2]+work[3];
	for( i = 0; i < arraysizeof( ranktbl); i ++ ) {
		if(  workrank >= ranktbl[i].num ) {
			petrank = i;
			break;
		}
	}

	if( i>= arraysizeof( ranktbl)) i = arraysizeof( ranktbl);
	CHAR_setInt( petindex, CHAR_PETRANK, petrank);

	for( i = 0; i < 10; i ++ ){
		int rnt = RAND( 0, 3 );
		if( rnt == 0 ) work[0]++;
		if( rnt == 1 ) work[1]++;
		if( rnt == 2 ) work[2]++;
		if( rnt == 3 ) work[3]++;
	}

    CHAR_setInt( petindex, CHAR_VITAL, ( PARAM_CAL(E_T_BASEVITAL) * work[0] ));
    CHAR_setInt( petindex, CHAR_STR , ( PARAM_CAL(E_T_BASESTR) * work[1] ));
    CHAR_setInt( petindex, CHAR_TOUGH , ( PARAM_CAL(E_T_BASETGH) * work[2] ));
    CHAR_setInt( petindex, CHAR_DEX , ( PARAM_CAL(E_T_BASEDEX) * work[3] ));
	CHAR_setMaxExp( petindex, 0);
	CHAR_setInt( petindex, CHAR_LV, level);
	//宠物技能设为七技
	CHAR_setInt( petindex, CHAR_SLOT, 7);
/*
	for( i=0; i<CHAR_MAXPETSKILLHAVE; i++)	{
		petskill = CHAR_getPetSkill( petindex, i);
		print("\n petskill = %d ", petskill);
		if( petskill == -1)	{
			
		}
	}
*/
#undef	E_PAR
#undef	ET_PAR
#undef	PARAM_CAL
    CHAR_complianceParameter( petindex );
	CHAR_setInt( petindex, CHAR_HP, CHAR_getWorkInt( petindex, CHAR_WORKMAXHP));
	if( CHAR_CHECKINDEX( toindex) ){
		CHAR_setWorkInt( petindex, CHAR_WORKPLAYERINDEX, toindex);
		CHAR_setChar( petindex, CHAR_OWNERCDKEY, CHAR_getChar( toindex, CHAR_CDKEY));
		CHAR_setChar( petindex, CHAR_OWNERCHARANAME, CHAR_getChar( toindex, CHAR_NAME));
	}
	CHAR_setInt ( petindex, CHAR_WHICHTYPE , CHAR_TYPEPET);
#ifdef _PET_2TRANS
	CHAR_setInt ( petindex, CHAR_TRANSMIGRATION, CHAR_getInt ( petindex, CHAR_TRANSMIGRATION )+1);
#else
	CHAR_setInt ( petindex, CHAR_TRANSMIGRATION, 1);
#endif
	return petindex;
}
#endif