enemy.c

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

/* 衬涩烂楮   */
#include "version.h"
#include <stdio.h>
#include <string.h>
#include "common.h"
#include "util.h"
#include "buf.h"
#include "char_base.h"
#include "char.h"
#include "configfile.h"
#include "encount.h"
#include "enemy.h"
#include "pet.h"
#include "enemyexptbl.h"
#include "petmail.h"
#include "battle.h"
#include "pet_skillinfo.h"
#include "anim_tbl.h"
#include "log.h"

#ifdef _ADD_ENCOUNT           // WON ADD 增加敌遭遇触发修件
#include "encount.h"
#include "npcutil.h"
#endif

#define		ENEMY_INDEXTABLEMAXSIZE		16
static ENEMY_EnemyTable *ENEMY_enemy;
static int              ENEMY_enemynum;

static ENEMYTEMP_Table *ENEMYTEMP_enemy;
static int              ENEMYTEMP_enemynum;

static GROUP_Table 		*GROUP_group;
static int              GROUP_groupnum;

int                     ENEMY_indextable[ENEMY_INDEXTABLEMAXSIZE];

#ifdef _ENEMY_FALLGROUND
extern	tagRidePetTable ridePetTable[296];
#endif

INLINE BOOL ENEMY_CHECKINDEX( int index)
{
    if( index < 0 || index >= ENEMY_enemynum) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMY_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= ENEMY_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMY_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= ENEMY_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int ENEMY_getInt( int index, ENEMY_DATAINT element)
{
    return ENEMY_enemy[index].intdata[element];
}

INLINE int *ENEMY_getIntdata( int index)
{
	return ENEMY_enemy[index].intdata;
}

INLINE int ENEMY_setInt( int index, ENEMY_DATAINT element, int data)
{
    int buf;
    buf = ENEMY_enemy[index].intdata[element];
    ENEMY_enemy[index].intdata[element] = data;
    return buf;
}

INLINE char *ENEMY_getChar( int index, ENEMY_DATACHAR element)
{
    if(!ENEMY_CHECKINDEX(index))return "\0";
    if(!ENEMY_CHECKCHARDATAINDEX(element))return "\0";

    return ENEMY_enemy[index].chardata[element].string;
}

INLINE BOOL ENEMY_setChar( int index ,ENEMY_DATACHAR element, char* new )
{
    if(!ENEMY_CHECKINDEX(index))return FALSE;
    if(!ENEMY_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( ENEMY_enemy[index].chardata[element].string,
                sizeof(ENEMY_enemy[index].chardata[element].string),
                new );
    return TRUE;
}

int ENEMY_getEnemyNum( void)
{
    return ENEMY_enemynum;
}

INLINE BOOL ENEMYTEMP_CHECKINDEX( int index)
{
    if( index < 0 || index >= ENEMYTEMP_enemynum) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMYTEMP_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= E_T_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMYTEMP_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= E_T_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int ENEMYTEMP_getInt( int index, ENEMYTEMP_DATAINT element)
{
    return ENEMYTEMP_enemy[index].intdata[element];
}

INLINE int ENEMYTEMP_setInt( int index, ENEMYTEMP_DATAINT element, int data)
{
    int buf;
    buf = ENEMYTEMP_enemy[index].intdata[element];
    ENEMYTEMP_enemy[index].intdata[element] = data;
    return buf;
}

INLINE char *ENEMYTEMP_getChar( int index, ENEMYTEMP_DATACHAR element)
{
    if(!ENEMYTEMP_CHECKINDEX(index))return "\0";
    if(!ENEMYTEMP_CHECKCHARDATAINDEX(element))return "\0";

    return ENEMYTEMP_enemy[index].chardata[element].string;
}

INLINE BOOL ENEMYTEMP_setChar( int index ,ENEMYTEMP_DATACHAR element, char* new )
{
    if(!ENEMYTEMP_CHECKINDEX(index))return FALSE;
    if(!ENEMYTEMP_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( ENEMYTEMP_enemy[index].chardata[element].string,
                sizeof(ENEMYTEMP_enemy[index].chardata[element].string),
                new );
    return TRUE;
}

int ENEMYTEMP_getEnemyNum( void)
{
    return ENEMYTEMP_enemynum;
}

INLINE BOOL GROUP_CHECKINDEX( int index)
{
    if( index < 0 || index >= GROUP_groupnum) return FALSE;
    return TRUE;
}

static INLINE BOOL GROUP_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= GROUP_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL GROUP_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= GROUP_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int GROUP_getInt( int index, GROUP_DATAINT element)
{
    return GROUP_group[index].intdata[element];
}

INLINE int GROUP_setInt( int index, GROUP_DATAINT element, int data)
{
    int buf;
    buf = GROUP_group[index].intdata[element];
    GROUP_group[index].intdata[element] = data;
    return buf;
}

INLINE char *GROUP_getChar( int index, GROUP_DATACHAR element)
{
    if(!GROUP_CHECKINDEX(index))return "\0";
    if(!GROUP_CHECKCHARDATAINDEX(element))return "\0";

    return GROUP_group[index].chardata[element].string;
}

INLINE BOOL GROUP_setChar( int index ,GROUP_DATACHAR element, char* new )
{
    if(!GROUP_CHECKINDEX(index))return FALSE;
    if(!GROUP_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( GROUP_group[index].chardata[element].string,
                sizeof(GROUP_group[index].chardata[element].string),
                new );
    return TRUE;
}

int GROUP_getEnemyNum( void)
{
    return GROUP_groupnum;
}

BOOL ENEMYTEMP_initEnemy( char* filename )
{
    FILE*   f;
    char    line[256];
    int     linenum=0;
    int     enemytemp_readlen=0;
	int		i,j;
    f = fopen(filename,"r");
    if( f == NULL ){
        print( "文件打开失败\n");
        return FALSE;
    }

    ENEMYTEMP_enemynum=0;

    /*  引内  躲卅垫互窒垫丐月井升丹井譬屯月    */
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );

        ENEMYTEMP_enemynum++;
    }

    if( fseek( f, 0, SEEK_SET ) == -1 ){
        fprint( "Seek Error\n" );
        fclose(f);
        return FALSE;
    }
    ENEMYTEMP_enemy = allocateMemory( sizeof(struct tagENEMYTEMP_Table)
                                   * ENEMYTEMP_enemynum );
    if( ENEMYTEMP_enemy == NULL ){
        fprint( "无法分配内存 %d\n" ,
                sizeof(struct tagENEMYTEMP_Table)*ENEMYTEMP_enemynum);
        fclose( f );
        return FALSE;
    }

	/* 赓渝祭 */
    for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
    	for( j = 0; j < E_T_DATAINTNUM; j ++ ) {
    		ENEMYTEMP_setInt( i,j,-1);
    	}
    }
    linenum = 0;
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );
        replaceString( line, '\t' , ' ' );
{
        char    buf[256];
        for( i = 0; i < strlen( line); i ++) {
            if( line[i] != ' ' ) {
                break;
            }
            strcpy( buf, &line[i]);
        }
        if( i != 0 ) {
            strcpy( line, buf);
        }
}
{
        char    token[256];
        int     ret;
		for( i = 0; i < E_T_DATACHARNUM; i ++ ) {
	        ret = getStringFromIndexWithDelim( line,",",i+1,token,
	                                           sizeof(token));
	        if( ret==FALSE ){
	            fprint("文件语法错误:%s 第%d行\n",filename,linenum);
	            continue;
	        }
	        ENEMYTEMP_setChar( enemytemp_readlen, E_T_NAME + i, token);

		}
#define	ENEMYTEMP_STARTINTNUM		(E_T_DATACHARNUM+1)
        for( i = ENEMYTEMP_STARTINTNUM; i < E_T_DATAINTNUM+ENEMYTEMP_STARTINTNUM; i ++ ) {
            ret = getStringFromIndexWithDelim( line,",",i,token,
                                               sizeof(token));
            if( ret==FALSE ){
                fprint("文件语法错误:%s 第%d行\n",filename,linenum);
                break;
            }
            if( strlen( token) != 0 ) {
	            ENEMYTEMP_setInt( enemytemp_readlen, i - ENEMYTEMP_STARTINTNUM, atoi( token));
			}
        }
        if( i < E_T_DATAINTNUM+ENEMYTEMP_STARTINTNUM ) continue;


        enemytemp_readlen ++;
}
    }
    fclose(f);

    ENEMYTEMP_enemynum = enemytemp_readlen;

    print( "有效宠物基本状态数是 %d...", ENEMYTEMP_enemynum );

    return TRUE;
}

BOOL ENEMYTEMP_reinitEnemy( void )
{
	freeMemory( ENEMYTEMP_enemy);
	return( ENEMYTEMP_initEnemy( getEnemyBasefile()));
}

int ENEMYTEMP_getEnemyTempArray( int enemyindex)
{
	if( !ENEMY_CHECKINDEX( enemyindex)) return -1;
	return ENEMY_enemy[enemyindex].enemytemparray;
}

int ENEMYTEMP_getEnemyTempArrayFromTempNo( int EnemyTempNo)
{
	int		i;
	for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
		if( ENEMYTEMP_getInt( i, E_T_TEMPNO) == EnemyTempNo) {
			return i;
		}
	}
	return -1;
}

int ENEMYTEMP_getEnemyTempArrayFromInitnum( int EnemyTempNo)
{
	int		i;
	for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
		if( ENEMYTEMP_getInt( i, E_T_INITNUM) == EnemyTempNo) {
			return i;
		}
	}
	return -1;
}

BOOL ENEMY_initEnemy( char* filename )
{
    FILE*   f;
    char    line[256];
    int     linenum=0;
    int     enemy_readlen=0;
	int		i,j;
    f = fopen(filename,"r");
    if( f == NULL ){
        print( "文件打开失败\n");
        return FALSE;
    }

    ENEMY_enemynum=0;
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );

        ENEMY_enemynum++;
    }

    if( fseek( f, 0, SEEK_SET ) == -1 ){
        fprint( "寻找失败\n" );
        fclose(f);
        return FALSE;
    }

    ENEMY_enemy = allocateMemory( sizeof(struct tagENEMY_EnemyTable)
                                   * ENEMY_enemynum );
    if( ENEMY_enemy == NULL ){
        fprint( "无法分配内存 %d\n" ,
                sizeof(struct tagENEMY_EnemyTable)*ENEMY_enemynum);
        fclose( f );
        return FALSE;
    }
    for( i = 0; i < ENEMY_enemynum; i ++ ) {
    	for( j = 0; j < ENEMY_DATAINTNUM; j ++ ) {
    		ENEMY_setInt( i,j,-1);
    	}
    }
    linenum = 0;
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );
        replaceString( line, '\t' , ' ' );
{
        char    buf[256];
        for( i = 0; i < strlen( line); i ++) {
            if( line[i] != ' ' ) {
                break;
            }
            strcpy( buf, &line[i]);
        }
        if( i != 0 ) {
            strcpy( line, buf);
        }
}
{
        char    token[256];
        int     ret;

        ret = getStringFromIndexWithDelim( line,",",1,token,sizeof(token));
        if( ret==FALSE ){
            fprint("文件语法错误:%s 第%d行\n",filename,linenum);
            continue;
        }
        ENEMY_setChar( enemy_readlen, ENEMY_NAME, token);
        ret = getStringFromIndexWithDelim( line,",",2,token,sizeof(token));
        if( ret==FALSE ){
            fprint("文件语法错误:%s 第%d行\n",filename,linenum);
            continue;
        }
        ENEMY_setChar( enemy_readlen, ENEMY_TACTICSOPTION, token);
#ifdef _BATTLENPC_WARP_PLAYER
	    ret = getStringFromIndexWithDelim( line, ",", 3, token, sizeof(token));
        if(ret==FALSE){
            fprint("文件语法错误:%s 第%d行\n",filename,linenum);
            continue;
        }
        ENEMY_setChar( enemy_readlen, ENEMY_ACT_CONDITION, token);
#endif

#ifdef _BATTLENPC_WARP_PLAYER
#define	ENEMY_STARTINTNUM		4
#else
#define	ENEMY_STARTINTNUM		3
#endif

        for( i = ENEMY_STARTINTNUM; i < ENEMY_DATAINTNUM+ENEMY_STARTINTNUM; i ++ ) {
            ret = getStringFromIndexWithDelim( line,",",i,token,sizeof(token));
            if( ret==FALSE ){
                fprint("文件语法错误:%s 第%d行\n",filename,linenum);
                break;
            }
            ENEMY_setInt( enemy_readlen, i - ENEMY_STARTINTNUM, atoi( token));
        }