profession_skill.c

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

#include "version.h"


#ifdef _PROFESSION_SKILL			// WON ADD 人物职业技能
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "buf.h"
#include "profession_skill.h"
#include "char_base.h"
#include "battle.h"
#include "magic_base.h"
#include "configfile.h"
#include "char.h"
#include "lssproto_serv.h"
#include "skill.h"

static Professionskill	*PROFESSION_skill;


typedef struct tagProfessionskill_skillFunctionTable
{
	char			*functionname;
	PROFESSION_SKILL_CALLFUNC	func;
	int				hash;
//	int				status;
}PROFESSION_SKILL_skillFunctionTable;

static PROFESSION_SKILL_skillFunctionTable PROFESSION_SKILL_functbl[] = {

// 巫师技能
	{ "PROFESSION_VOLCANO_SPRINGS", PROFESSION_volcano_springs, 0 },	// 火山泉
	{ "PROFESSION_FIRE_BALL",		PROFESSION_fire_ball,		0 },	// 火星球
	{ "PROFESSION_FIRE_SPEAR",		PROFESSION_fire_spear,		0 },	// 火龙枪
	{ "PROFESSION_SUMMON_THUNDER",  PROFESSION_summon_thunder,  0 },	// 召雷术
	{ "PROFESSION_CURRENT",			PROFESSION_current,			0 },	// 电流术
	{ "PROFESSION_STORM",			PROFESSION_storm,			0 },	// 暴风雨
	{ "PROFESSION_ICE_ARROW",		PROFESSION_ice_arrow,		0 },	// 冰箭术
	{ "PROFESSION_ICE_CRACK",		PROFESSION_ice_crack,		0 },	// 冰爆术
	{ "PROFESSION_ICE_MIRROR",		PROFESSION_ice_mirror,		0 },	// 冰镜术
	{ "PROFESSION_DOOM",			PROFESSION_doom,			0 },	// 世界末日
	{ "PROFESSION_BLOOD",			PROFESSION_blood,			0 },	// 嗜血成性
	{ "PROFESSION_BLOOD_WORMS",		PROFESSION_blood_worms,		0 },	// 嗜血蛊
	{ "PROFESSION_SIGN",			PROFESSION_sign,			0 },	// 一针见血
	{ "PROFESSION_FIRE_ENCLOSE",	PROFESSION_fire_enclose,	0 },	// 火附体
	{ "PROFESSION_ICE_ENCLOSE",		PROFESSION_ice_eclose,		0 },	// 冰附体
	{ "PROFESSION_THUNDER_ENCLOSE",	PROFESSION_thunder_enclose, 0 },	// 雷附体
	{ "PROFESSION_FIRE_PRACTICE",	PROFESSION_fire_practice,	0 },	// 火魔法熟练度
	{ "PROFESSION_ICE_PRACTICE",	PROFESSION_ice_practice,	0 },	// 冰魔法熟练度
	{ "PROFESSION_THUNDER_PRACTICE",PROFESSION_thunder_practice,0 },	// 雷魔法熟练度
	{ "PROFESSION_ENCLOSE",			PROFESSION_enclose,			0 },	// 附身术
	{ "PROFESSION_TRANSPOSE",		PROFESSION_transpose,		0 },	// 移形换位
//	{ "PROFESSION_ALCHEMY",			PROFESSION_alchemy,			0 },	// 炼金术

// 勇士技能
	{ "PROFESSION_CHAIN_ATK",		PROFESSION_chain_atk,		0 },	// 连环攻击
	{ "PROFESSION_AVOID",			PROFESSION_avoid,			0 },	// 回避
	{ "PROFESSION_WEAPON_FOCUS",	PROFESSION_weapon_focus,	0 },	// 武器专精	
	{ "PROFESSION_REBACK",			PROFESSION_reback,			0 },	// 状态回复
	{ "PROFESSION_BRUST",			PROFESSION_brust,			0 },	// 爆击
	{ "PROFESSION_CHAIN_ATK_2",		PROFESSION_chain_atk_2,		0 },	// 双重攻击
	{ "PROFESSION_SCAPEGOAT",		PROFESSION_scapegoat,		0 },	// 舍已为友
	{ "PROFESSION_ENRAGE",			PROFESSION_enrage,			0 },	// 激化攻击
	{ "PROFESSION_ENERGY_COLLECT",	PROFESSION_energy_collect,	0 },	// 能量聚集
	{ "PROFESSION_FOCUS",			PROFESSION_focus,			0 },	// 专注战斗
	{ "PROFESSION_SHIELD_ATTACK",	PROFESSION_shield_attack,	0 },	// 盾击
	{ "PROFESSION_DUAL_WEAPON",		PROFESSION_dual_weapon,		0 },	// 二刀流	
	{ "PROFESSION_DEFLECT",			PROFESSION_deflect,			0 },	// 格档
	{ "PROFESSION_THROUGH_ATTACK",	PROFESSION_through_attack,	0 },	// 贯穿攻击
	{ "PROFESSION_CAVALRY",			PROFESSION_cavalry,			0 },	// 座骑攻击
	{ "PROFESSION_DEAD_ATTACK",		PROFESSION_dead_attack,		0 },	// 濒死攻击
	{ "PROFESSION_CONVOLUTE",		PROFESSION_convolute,		0 },	// 回旋攻击
	{ "PROFESSION_CHAOS",			PROFESSION_chaos,			0 },	// 混乱攻击

// 猎人
	{ "PROFESSION_TRACK",			PROFESSION_track,			0 },	// 追寻敌踪
	{ "PROFESSION_ESCAPE",			PROFESSION_escape,			0 },	// 回避战斗
	{ "PROFESSION_DOCILE",			PROFESSION_docile,			0 },	// 驯伏宠物
	{ "PROFESSION_TRAP",			PROFESSION_trap,			0 },	// 陷阱
	{ "PROFESSION_ENRAGE_PET",		PROFESSION_enrage_pet,		0 },	// 激怒宠物
	{ "PROFESSION_DRAGNET",			PROFESSION_dragnet,			0 },	// 天罗地网
	{ "PROFESSION_ENTWINE",			PROFESSION_entwine,			0 },	// 树根缠绕
	{ "PROFESSION_AUTARKY",			PROFESSION_autarky,			0 },	// 自给自足
	{ "PROFESSION_PLUNDER",			PROFESSION_plunder,			0 },	//   体掠夺
	{ "PROFESSION_TOXIN_WEAPON",	PROFESSION_toxin_weapon,	0 },	// 毒素武器
	{ "PROFESSION_RESIST_FIRE",		PROFESSION_resist_fire,		0 },	// 火抗性
	{ "PROFESSION_RESIST_ICE",		PROFESSION_resist_ice,		0 },	// 冰抗性
	{ "PROFESSION_RESIST_THUNDER",	PROFESSION_resist_thunder,	0 },	// 雷抗性
#ifdef _PROFESSION_ADDSKILL
    { "PROFESSION_RESIST_F_I_T",    PROFESSION_resist_f_i_t,    0 },    // 自然威能
	{ "PROFESSION_CALL_NATURE",     PROFESSION_call_nature,     0 },    // 号召自然
	{ "PROFESSION_BOUNDARY",        PROFESSION_boundary,     0 },       // 四属性结界
#endif
	{ "PROFESSION_G_RESIST_FIRE",	PROFESSION_g_resist_fire,	0 },	// 团体火抗性
	{ "PROFESSION_G_RESIST_ICE",	PROFESSION_g_resist_ice,	0 },	// 团体冰抗性
	{ "PROFESSION_G_RESIST_THUNDER",PROFESSION_g_resist_thunder,0 },	// 团体雷抗性
	{ "PROFESSION_ATTACK_WEAK",		PROFESSION_attack_weak,		0 },	// 弱点攻击
	{ "PROFESSION_INSTIGATE",		PROFESSION_instigate,		0 },	// 挑拨
	{ "PROFESSION_OBLIVION",		PROFESSION_oblivion,		0 },	// 遗忘

// 共同技能
	{ "PROFESSION_FULL_MP",			PROFESSION_full_mp,			0 },	// 气力充沛
	{ "PROFESSION_STRONG_BACK",		PROFESSION_strong_back,		0 },	// 负重增加
	{ "PROFESSION_STRENGTHEN",		PROFESSION_strengthen,		0 },	// 自我强化

};


static int profession_skill_num;				// 职业技能总数

// 将 profession.txt 载入
BOOL PROFESSION_initSkill( char *filename)
{

	FILE*   f;
    char    line[256];
    int     linenum=-1;
	int     skill_readlen=0;
	int		i, j;

	int max_skillid = 0;

    f = fopen(filename,"r");
    if( f == NULL ){
        print( "file open error\n");
        return FALSE;
    }

    profession_skill_num=0;

    while( fgets( line, sizeof( line ), f ) ){
		char    token[256];

        linenum ++;
        if( line[0] == '#' )continue;
        if( line[0] == '\n' )continue;
        chomp( line );
        profession_skill_num++;
#ifdef _PROSKILL_OPTIMUM // Robin 取出最大职技ID
		if( getStringFromIndexWithDelim( line, ",", 
				PROFESSION_SKILL_DATACHARNUM+PROFESSION_SKILL_ID+1,
				token, sizeof(token)) == FALSE )
			continue;
		max_skillid = max( atoi( token), max_skillid);
#endif
    }

    if( fseek( f, 0, SEEK_SET ) == -1 ){
        fprint( "Seek Error\n" );
        fclose(f);
        return FALSE;
    }

#ifdef _PROSKILL_OPTIMUM // 职技Table数为 最大技能ID +1
	profession_skill_num = max_skillid +1;
	print("最大职技ID = %d ...", max_skillid);
#endif

	PROFESSION_skill = allocateMemory( sizeof(struct tagProfessionkill) * profession_skill_num + 1 );


	if( PROFESSION_skill == NULL ){
        fprint( "无法分配内存 %d\n", sizeof(struct tagProfessionkill)*profession_skill_num);
        fclose( f );
        return FALSE;
    }

	// init skill
    for( i = 0; i < profession_skill_num; i ++ ) {
    	for( j = 0; j < PROFESSION_SKILL_DATAINTNUM; j ++ )
    		PROFESSION_SKILL_setInt( i,j,-1);
    
    	for( j = 0; j < PROFESSION_SKILL_DATACHARNUM; j ++ ) 
    		PROFESSION_SKILL_setChar( i,j,"");    
    }

    linenum = -1;
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;
        if( line[0] == '\n' )continue;             
                
        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;

#ifdef _PROSKILL_OPTIMUM // 读取本行职技的ID, 直接以职技ID当Table index
			ret = getStringFromIndexWithDelim( line, ",", PROFESSION_SKILL_DATACHARNUM+PROFESSION_SKILL_ID+1, token, sizeof(token));
			if( ret==FALSE ){
				fprint("Syntax Error file:%s line:%d\n",filename,linenum);
				break;
			}
			skill_readlen = atoi( token);
#endif
			for( i = 0; i < PROFESSION_SKILL_DATACHARNUM; i ++ ) {

			    ret = getStringFromIndexWithDelim( line,",", i + 1, token,sizeof(token));
				if( ret==FALSE ){
					fprint("Syntax Error file:%s line:%d\n",filename,linenum);
					break;
				} 
				PROFESSION_SKILL_setChar( skill_readlen, i, token);
			} 

			for( i = 0; i < PROFESSION_SKILL_DATAINTNUM; i ++ ) {
				ret = getStringFromIndexWithDelim( line, ",", i+PROFESSION_SKILL_DATACHARNUM+1, token, sizeof(token));
				
				if( ret==FALSE ){
					fprint("文件语法错误:%s 第%d行\n",filename,linenum);
					break;
				} 
				if( strlen( token) != 0 ) {
					PROFESSION_SKILL_setInt( skill_readlen, i , atoi( token ));
				} 
			}         		
			skill_readlen ++;
		} 		
    } 
    fclose(f);

    profession_skill_num = skill_readlen;

	for( i = 0; i < arraysizeof( PROFESSION_SKILL_functbl); i ++ ){
		PROFESSION_SKILL_functbl[i].hash = hashpjw( PROFESSION_SKILL_functbl[i].functionname );
	}

    return TRUE;

}


// 重新载入 profession.txt
void rePROFESSION_initSkill()
{
	freeMemory( PROFESSION_skill );
	PROFESSION_initSkill(getProfession());
}

INLINE BOOL PROFESSION_SKILL_CHECKINDEX( int index )
{
    if( profession_skill_num < index || index < 0 )return FALSE;
    return TRUE;
}

static INLINE BOOL PROFESSION_SKILL_CHECKINTDATAINDEX( int index)
{
	if( PROFESSION_SKILL_DATAINTNUM < index || index < 0 ) return FALSE;
	return TRUE;
}

static INLINE BOOL PROFESSION_SKILL_CHECKCHARDATAINDEX( int index)
{
	if( PROFESSION_SKILL_DATACHARNUM < index || index < 0 ) return FALSE;
	return TRUE;
}

INLINE int PROFESSION_SKILL_getInt( int index, PROFESSION_SKILL_DATAINT element)
{
	return PROFESSION_skill[index].data[element];
}

INLINE int PROFESSION_SKILL_setInt( int index, PROFESSION_SKILL_DATAINT element, int data)
{
	int buf;
	buf = PROFESSION_skill[index].data[element];
	PROFESSION_skill[index].data[element]=data;
	return buf;
}

INLINE char* PROFESSION_SKILL_getChar( int index, PROFESSION_SKILL_DATACHAR element)
{
	if( !PROFESSION_SKILL_CHECKINDEX( index)) return NULL;
	if( !PROFESSION_SKILL_CHECKCHARDATAINDEX( element)) return NULL;
	return PROFESSION_skill[index].string[element].string;
}

INLINE BOOL PROFESSION_SKILL_setChar( int index ,PROFESSION_SKILL_DATACHAR element, char* new )
{
    if(!PROFESSION_SKILL_CHECKINDEX(index))return FALSE;
    if(!PROFESSION_SKILL_CHECKCHARDATAINDEX(element))return FALSE;

    strcpysafe( PROFESSION_skill[index].string[element].string,
                sizeof(PROFESSION_skill[index].string[element].string),
                new );
    return TRUE;
}

int PROFESSION_SKILL_getskillNum( void)
{
	return profession_skill_num;
}


/*----------------------------------------------------------------------*/

int PROFESSION_SKILL_getskillArray( int skillid)
{
#ifdef _PROSKILL_OPTIMUM // 查询职技ID改为阵列式
	if( skillid >= 0 && skillid < profession_skill_num )
		return PROFESSION_skill[skillid].data[PROFESSION_SKILL_ID];
#else
	int		i;
	for( i = 0; i <= profession_skill_num; i ++ ) { // 待优化
		if( PROFESSION_skill[i].data[PROFESSION_SKILL_ID] == skillid ) 
			return i;
	}
#endif
	return -1;
}

PROFESSION_SKILL_CALLFUNC PROFESSION_SKILL_getskillFuncPointer(char* name )
{
    int i;
    int hash = hashpjw( name );
	
	for( i = 0; i< arraysizeof( PROFESSION_SKILL_functbl); i++ ){
		if( PROFESSION_SKILL_functbl[i].hash == hash ){
        	if( strcmp( PROFESSION_SKILL_functbl[i].functionname, name ) == 0 ){
	            return PROFESSION_SKILL_functbl[i].func;
			}
		}
	}

    return NULL;
}

int _PROFESSION_SKILL_GetArray( char *file, int line, int charaindex, int skill )
{
	int		skillid,array;

	skillid = CHAR_getCharSkill( charaindex, skill);

	if( skillid < 0 )	return -1;

	array = PROFESSION_SKILL_getskillArray( skillid );
		
	return array;
}


/*----------------------------------------------------------------------*/

// 使用职业技能
int PROFESSION_SKILL_Use( int charaindex, int skill, int toNo, char *data )
{
	int		Pskillid, skillid;
	int		ret=-1, skill_level;
	PROFESSION_SKILL_CALLFUNC func;
	CHAR_HaveSkill* hskill;
	int char_pskill, profession_skill;

	skillid = CHAR_getCharSkill( charaindex, skill);
	Pskillid = PROFESSION_SKILL_getskillArray( skillid);
	//print("\n skillid:%d Pskillid:%d ", skillid, Pskillid); // Robin log
	if( Pskillid == -1 ) {
		printf("\n 改封包??找不到该职技! ");
		return ret;
	}

#ifdef _PROSKILL_OPTIMUM	// Robin fix 检查职业是否相符
	char_pskill = CHAR_getInt( charaindex, PROFESSION_CLASS );
	profession_skill = PROFESSION_SKILL_getInt( Pskillid, PROFESSION_SKILL_PROFESSION_CLASS);
	if( (char_pskill <=0) || (char_pskill != profession_skill) ) {
		print("\n 改封包??职技的职业不正确!:%d:%d ", char_pskill, profession_skill);
		return ret;
	}
#endif

	// 找寻对应 function
	func = PROFESSION_SKILL_getskillFuncPointer( PROFESSION_SKILL_getChar( Pskillid, PROFESSION_SKILL_FUNCNAME) );

	// 判断是否为人物
	if( CHAR_getInt( charaindex, CHAR_WHICHTYPE) != CHAR_TYPEPLAYER )	return ret;


	if( func ){
		// 人物技能等级
		hskill = CHAR_getCharHaveSkill( charaindex, skill );
		skill_level = SKILL_getInt( &hskill->skill, SKILL_LEVEL);
	
		// 耗损 MP 
		if( PROFESSION_SKILL_DEC_COST_MP( charaindex, skill, Pskillid, skill_level ) != 1 )	{
			print("\n Error:职技MP:%d:%d:%d ", skill, Pskillid, skill_level);
			return ret;
		}

		// 使用职业技能
		ret = func( charaindex, toNo, Pskillid, data, skill_level );
		if( ret == -1 ){
			int rands = rand()%10;
			//andy_log
			print("ret = %d, rands:%d \n", ret, rands);
			if( rands > 5 ) return ret;
		}

		if( Pskillid == 57 //激怒宠物 选宠物才有经验值
			&& CHAR_getInt( BATTLE_No2Index( CHAR_getWorkInt( charaindex, CHAR_WORKBATTLEINDEX ), toNo ), CHAR_WHICHTYPE) != CHAR_TYPEPET ) 
			return ret;

		// 一般技能升级
		PROFESSION_NORMAL_SKILL_LEVLE_UP( &hskill->skill, Pskillid, charaindex );
	}
	else {
		print("\n 错误!找不到职技func ");
	}

	return ret;
}

// 特殊技能升级
void PROFESSION_SKILL_LVEVEL_UP( int charaindex, char *name )
{
	int skill=-1;
	int skillid=0, Pskillid=0, i;
	char *skill_name;