Sancaros/chuyiwen_gmsv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
bea5ac05b3
chuyiwen_gmsv/char/enemy.c

2760 lines
84 KiB
C
Raw Normal View History

sq_gmsv_chuyiwen sa_sever
2016-12-24 08:45:52 +08:00
/* <20><>ɬ<EFBFBD><C9AC><EFBFBD><EFBFBD> */
#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 <20><><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>޼<EFBFBD>
#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( "<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>\n");
return FALSE;
}
ENEMYTEMP_enemynum=0;
/* <20><><EFBFBD><EFBFBD> <20><>ئ<EFBFBD>滥<EFBFBD>ϵ<EFBFBD>ؤ<EFBFBD>¾<EFBFBD><C2BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʃ<EFBFBD><C6A9><EFBFBD><EFBFBD> */
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( "<EFBFBD>޷<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD> %d\n" ,
sizeof(struct tagENEMYTEMP_Table)*ENEMYTEMP_enemynum);
fclose( f );
return FALSE;
}
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
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("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\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("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\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( "<EFBFBD><EFBFBD>Ч<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>״̬<EFBFBD><EFBFBD><EFBFBD><EFBFBD> %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( "<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>\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( "Ѱ<EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>\n" );
fclose(f);
return FALSE;
}
ENEMY_enemy = allocateMemory( sizeof(struct tagENEMY_EnemyTable)
* ENEMY_enemynum );
if( ENEMY_enemy == NULL ){
fprint( "<EFBFBD>޷<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD> %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("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
continue;
}
ENEMY_setChar( enemy_readlen, ENEMY_NAME, token);
ret = getStringFromIndexWithDelim( line,",",2,token,sizeof(token));
if( ret==FALSE ){
fprint("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\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("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\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("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
break;
}
ENEMY_setInt( enemy_readlen, i - ENEMY_STARTINTNUM, atoi( token));
}
if( i < ENEMY_DATAINTNUM+ENEMY_STARTINTNUM ) continue;
for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
if( ENEMYTEMP_getInt( i, E_T_TEMPNO)== ENEMY_getInt( enemy_readlen, ENEMY_TEMPNO)){
break;
}
}
if( i == ENEMYTEMP_enemynum) {
fprint("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
continue;
}
ENEMY_enemy[enemy_readlen].enemytemparray = i;
{
int lv_min, lv_max;
lv_min = ENEMY_getInt( enemy_readlen, ENEMY_LV_MIN);
lv_max = ENEMY_getInt( enemy_readlen, ENEMY_LV_MAX);
if( lv_min == 0 ) lv_min = lv_max;
ENEMY_setInt( enemy_readlen, ENEMY_LV_MIN, min( lv_min, lv_max));
ENEMY_setInt( enemy_readlen, ENEMY_LV_MAX, max( lv_min, lv_max));
}
enemy_readlen ++;
}
}
fclose(f);
ENEMY_enemynum = enemy_readlen;
print( "<EFBFBD><EFBFBD>Ч<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> %d..", ENEMY_enemynum );
return TRUE;
}
/*------------------------------------------------------------------------
* ENEMY_enemy<EFBFBD><EFBFBD>ɬ<EFBFBD>ð<EFBFBD><EFBFBD><EFBFBD><EFBFBD>̻<EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
BOOL ENEMY_reinitEnemy( void )
{
freeMemory( ENEMY_enemy);
return( ENEMY_initEnemy( getEnemyfile()));
}
/*------------------------------------------------------------------------
ENEMY_Enemy<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٯë<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
int ENEMY_getEnemyArrayFromIndex( int groupindex, int index)
{
if( !GROUP_CHECKINDEX( groupindex)) return -1;
if( index < 0 || index >= CREATEPROB1 - ENEMY_ID1) return -1;
return GROUP_group[groupindex].enemyarray[index];
}
/*------------------------------------------------------------------------
* ENEMY_ID <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ENEMY_Enemy<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٯë<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
int ENEMY_getEnemyArrayFromId( int EnemyId)
{
int i;
for( i = 0; i < ENEMY_enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_ID) == EnemyId) {
return i;
}
}
return -1;
}
int ENEMY_getEnemyArrayFromTempNo( int EnemyTempNo)
{
int i;
for( i = 0; i < ENEMY_enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_TEMPNO) == EnemyTempNo) {
return i;
}
}
return -1;
}
int ENEMY_getEnemyIdFromTempNo( int EnemyTempNo)
{
int i;
for( i = 0; i < ENEMY_enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_TEMPNO) == EnemyTempNo) {
return ENEMY_getInt( i, ENEMY_ID);
}
}
return -1;
}
int ENEMY_getEnemyTempNoFromId( int EnemyId)
{
int i;
for( i = 0; i < ENEMY_enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_ID) == EnemyId) {
return ENEMY_getInt( i, ENEMY_TEMPNO);
}
}
return -1;
}
/*------------------------------------------------------------------------
* <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɬ<EFBFBD>ð<EFBFBD><EFBFBD><EFBFBD><EFBFBD>̻<EFBFBD>ë <EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
BOOL GROUP_initGroup( char* filename )
{
FILE* f;
char line[256];
int linenum=0;
int group_readlen=0;
int i,j;
f = fopen(filename,"r");
if( f == NULL ){
print( "<EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>\n");
return FALSE;
}
GROUP_groupnum=0;
/* <20><><EFBFBD><EFBFBD> <20><>ئ<EFBFBD>滥<EFBFBD>ϵ<EFBFBD>ؤ<EFBFBD>¾<EFBFBD><C2BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʃ<EFBFBD><C6A9><EFBFBD><EFBFBD> */
while( fgets( line, sizeof( line ), f ) ){
linenum ++;
if( line[0] == '#' )continue; /* comment */
if( line[0] == '\n' )continue; /* none */
chomp( line );
GROUP_groupnum++;
}
if( fseek( f, 0, SEEK_SET ) == -1 ){
fprint( "Ѱ<EFBFBD><EFBFBD>ʧ<EFBFBD><EFBFBD>\n" );
fclose(f);
return FALSE;
}
GROUP_group = allocateMemory( sizeof(struct tagGROUP_Table)
* GROUP_groupnum );
if( GROUP_group == NULL ){
fprint( "<EFBFBD>޷<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڴ<EFBFBD> %d\n" ,
sizeof(struct tagGROUP_Table)*GROUP_groupnum);
fclose( f );
return FALSE;
}
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
for( i = 0; i < GROUP_groupnum; i ++ ) {
for( j = 0; j < GROUP_DATAINTNUM; j ++ ) {
GROUP_setInt( i,j,-1);
}
for( j = 0; j < CREATEPROB1 - ENEMY_ID1; j ++ ) {
GROUP_group[i].enemyarray[j] = -1;
}
}
/* <20><><EFBFBD><EFBFBD> <20><> <20><> */
linenum = 0;
while( fgets( line, sizeof( line ), f ) ){
linenum ++;
if( line[0] == '#' )continue; /* comment */
if( line[0] == '\n' )continue; /* none */
chomp( line );
/* <20><>ë<EFBFBD><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
/* <20><><EFBFBD><EFBFBD> tab ë " " <20><> <20>徧<EFBFBD><E5BEA7><EFBFBD><EFBFBD> */
replaceString( line, '\t' , ' ' );
/* <20><> <20><><EFBFBD><EFBFBD>ʸ<EFBFBD><CAB8><EFBFBD><EFBFBD>ë<EFBFBD><C3AB><EFBFBD>£<EFBFBD>*/
{
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;
int loop;
/* <20><><EFBFBD><EFBFBD><EFBFBD>֨<EFBFBD>պ<EFBFBD><D5BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD><DDBC>׻<EFBFBD><D7BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƻ<EFBFBD><C6BB><EFBFBD><EFBFBD><EFBFBD> */
for( j = 0; j < GROUP_DATAINTNUM; j ++ ) {
GROUP_setInt( group_readlen,j,-1);
}
for( j = 0; j < CREATEPROB1 - ENEMY_ID1; j ++ ) {
GROUP_group[group_readlen].enemyarray[j] = -1;
}
/* <20><><EFBFBD>繴<EFBFBD><E7B9B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD>ëέ<C3AB><CEAD> */
ret = getStringFromIndexWithDelim( line,",",1,token,
sizeof(token));
if( ret==FALSE ){
fprint("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
continue;
}
GROUP_setChar( group_readlen, GROUP_NAME, token);
/* 2<><32> <20><><EFBFBD>Ϸ<EFBFBD><CFB7>Ѱ<EFBFBD><D1B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
#define GROUP_STARTINTNUM 2
for( i = GROUP_STARTINTNUM; i < GROUP_DATAINTNUM+GROUP_STARTINTNUM; i ++ ) {
ret = getStringFromIndexWithDelim( line,",",i,token,
sizeof(token));
if( ret==FALSE ){
fprint("<EFBFBD>ļ<EFBFBD><EFBFBD>﷨<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
break;
}
if( strlen( token) != 0 ) {
GROUP_setInt( group_readlen, i - GROUP_STARTINTNUM, atoi( token));
}
}
if( i < GROUP_DATAINTNUM+GROUP_STARTINTNUM ) continue;
{
int enemycnt = 0;
for( loop = ENEMY_ID1; loop < CREATEPROB1; loop ++ ) {
if( GROUP_getInt( group_readlen, loop) != -1 ) {
for( i = 0; i < ENEMY_enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_ID)
== GROUP_getInt( group_readlen, loop))
{
break;
}
}
if( i == ENEMY_enemynum) {
i = -1;
GROUP_setInt( group_readlen, loop, -1);
}
else {
enemycnt ++;
}
GROUP_group[group_readlen].enemyarray[loop - ENEMY_ID1] = i;
}
}
if( enemycnt == 0 ) {
fprint("<EFBFBD>Ŷ<EFBFBD><EFBFBD>趨<EFBFBD>е<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>δ<EFBFBD>趨 <20>ļ<EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
continue;;
}
if( checkRedundancy( &GROUP_group[group_readlen].intdata[ENEMY_ID1],
CREATEPROB1 - ENEMY_ID1))
{
fprint("<EFBFBD>Ŷ<EFBFBD><EFBFBD>趨<EFBFBD>е<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ظ<EFBFBD><EFBFBD>趨 <20>ļ<EFBFBD>:%s <20><>%d<><64>\n",filename,linenum);
continue;;
}
}
group_readlen ++;
}
}
fclose(f);
GROUP_groupnum = group_readlen;
print( "<EFBFBD><EFBFBD>Ч<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ⱥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> %d...", GROUP_groupnum );
return TRUE;
}
/*------------------------------------------------------------------------
* <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɬ<EFBFBD>ð<EFBFBD><EFBFBD><EFBFBD><EFBFBD>̻<EFBFBD> <EFBFBD><EFBFBD> <EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
BOOL GROUP_reinitGroup( void )
{
freeMemory( GROUP_group);
return( GROUP_initGroup( getGroupfile()));
}
/*------------------------------------------------------------------------
* GROUP_ID <EFBFBD><EFBFBD><EFBFBD><EFBFBD>GROUP_Group<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ٯë<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
int GROUP_getGroupArray( int groupid)
{
int i;
for( i = 0; i < GROUP_groupnum; i ++ ) {
if( GROUP_getInt( i, GROUP_ID) == groupid) {
return i;
}
}
return -1;
}
/*------------------------------------------------------------------------
* <EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ë<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>£<EFBFBD>
*-----------------------------------------------------------------------*/
static int ENEMY_getExp( int array,int tarray, int level, int rank )
{
int ret;
int *p;
int *tp;
float ranknum = 0.0;
float alpha;
struct {
int num;
float rank;
}ranktbl[] = {
{ 100, 2.5},
{ 95, 2.0},
{ 90, 1.5},
{ 85, 1.0},
{ 80, 0.5},
{ 0, 0.0},
};
level --;
if( level < 0 || level >= arraysizeof( enemybaseexptbl)) return 0;
p = ENEMY_enemy[array].intdata;
tp = ENEMYTEMP_enemy[tarray].intdata;
// <20>¼<EFBFBD><C2BC>;<EFBFBD><CDBE><EFBFBD> ë<><C3AB>
if( rank < 0 || rank > 5 ) rank = 0;
ranknum = ranktbl[rank].rank;
alpha = ( *( tp + E_T_CRITICAL) + *( tp + E_T_COUNTER) + *(tp + E_T_GET)
+ *( tp + E_T_POISON) + *( tp + E_T_PARALYSIS) + *(tp + E_T_SLEEP)
+ *( tp + E_T_STONE) + *( tp + E_T_DRUNK) + *(tp + E_T_CONFUSION)
) / 100.0
+ *( tp + E_T_RARE);
/* EXP<58><50><EFBFBD><EFBFBD> EXP<58>֣<EFBFBD> <20>¼<EFBFBD><C2BC>͡<EFBFBD>ϫ <20><><EFBFBD><EFBFBD>ì<EFBFBD><C3AC><EFBFBD><EFBFBD>*/
//return enemybaseexptbl[*(p+ENEMY_LV)] + (ranknum + alpha)*(*(tp+ENEMY_LV));
ret = enemybaseexptbl[level] + (ranknum + alpha)*(level+1);
return ( ret < 1 ) ? 1 : ret;
}
int ENEMY_getRank( int array, int tarray ){
int *p;
int *tp;
int paramsum;
int i;
int ranknum;
struct {
int num;
float rank;
}ranktbl[] = {
{ 100, 2.5}, //<2F>ܳɳ<DCB3><C9B3><EFBFBD> >= 100 petrank=0
{ 95, 2.0},
{ 90, 1.5},
{ 85, 1.0},
{ 80, 0.5},
{ 0, 0.0},
};
p = ENEMY_enemy[array].intdata;
tp = ENEMYTEMP_enemy[tarray].intdata;
/* <20>¼<EFBFBD><C2BC><EFBFBD>ë<EFBFBD><C3AB>ң<EFBFBD><D2A3><EFBFBD><EFBFBD> */
/* <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> ̤ë<CCA4><C3AB><EFBFBD>ټ<EFBFBD><D9BC>ǣ<EFBFBD> */
paramsum = *( tp + E_T_BASEVITAL) +
*( tp + E_T_BASESTR) +
*( tp + E_T_BASETGH) +
*( tp + E_T_BASEDEX);
ranknum = 0; // <20><><EFBFBD><EFBFBD><EFBFBD>ɻ<EFBFBD><C9BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for( i = 0; i < arraysizeof( ranktbl); i ++ ) {
if( paramsum >= ranktbl[i].num ) {
ranknum = i;
break;
}
}
return ranknum;
}
//*********************************************************
// <20>¼<EFBFBD>ĸةئ
//*********************************************************
static int EnemyGymSkill[] = {
PETSKILL_GUARDBREAK, // <20>⡰<EFBFBD><E2A1B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(3)
PETSKILL_CONTINUATIONATTACK1, // <20><><EFBFBD>ߡ<EFBFBD> <20><> <20><>(10)
PETSKILL_CONTINUATIONATTACK2, // <20><><EFBFBD>ࡰ <20><> <20><>(11)
PETSKILL_CONTINUATIONATTACK3, // <20><><EFBFBD>ᡰ <20><> <20><>(12)
PETSKILL_CHARGE1, // <20><><EFBFBD>ߡ<EFBFBD><DFA1><EFBFBD><EFBFBD>ҡ<EFBFBD><D2A1><EFBFBD><EFBFBD><EFBFBD>(30)
PETSKILL_CHARGE2, // <20><><EFBFBD>ࡰ<EFBFBD><E0A1B0><EFBFBD>ҡ<EFBFBD><D2A1><EFBFBD><EFBFBD><EFBFBD>(31)
PETSKILL_MIGHTY1, // <20><><EFBFBD>ߡ<EFBFBD><DFA1><EFBFBD><EFBFBD><EFBFBD> ڽ(40)
PETSKILL_MIGHTY2, // <20><><EFBFBD>ࡰ<EFBFBD><E0A1B0><EFBFBD><EFBFBD> ڽ(41)
PETSKILL_POWERBALANCE1, // <20><><EFBFBD>ߡ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(50)
PETSKILL_POWERBALANCE2, // <20><><EFBFBD>ࡰ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(51)
PETSKILL_POWERBALANCE3, // <20><><EFBFBD>ᡰ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(52)
PETSKILL_POISON_ATTACK1, // <20><><EFBFBD>ߡ<EFBFBD> <20><>(60)
PETSKILL_POISON_ATTACK2, // <20><><EFBFBD>ࡰ <20><>(61)
PETSKILL_STONE, // <20><><EFBFBD>ߡ<EFBFBD><DFA1>޼<EFBFBD> <20><>(80)
PETSKILL_CONFUSION_ATTACK, // <20><><EFBFBD>ߡ<EFBFBD><DFA1><EFBFBD><EFBFBD><EFBFBD> <20><>(90)
PETSKILL_DRUNK_ATTACK, // <20><><EFBFBD>ߨߡ<DFA8><DFA1><EFBFBD><EFBFBD><EFBFBD> <20><>(100)
PETSKILL_SLEEP_ATTACK, // <20><><EFBFBD><EFBFBD><EFBFBD>ߡ<EFBFBD><DFA1><EFBFBD>Ի <20><>(110)
PETSKILL_NOGUARD1, // <20><><EFBFBD><EFBFBD><EFBFBD>ߡ<EFBFBD><DFA1>á<EFBFBD><C3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(150)
PETSKILL_NOGUARD2, // <20><><EFBFBD><EFBFBD><EFBFBD>ࡰ<EFBFBD>á<EFBFBD><C3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(151)
PETSKILL_NOGUARD3, // <20><><EFBFBD><EFBFBD><EFBFBD>ᡰ<EFBFBD>á<EFBFBD><C3A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(152)
#ifdef _PSKILL_FALLGROUND
PETSKILL_FALLGROUND, //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#endif
#ifdef _SKILL_DAMAGETOHP
PETSKILL_DAMAGETOHP, //<2F><>Ѫ<EFBFBD><D1AA>
#endif
#ifdef _Skill_MPDAMAGE
PETSKILL_MPDAMAGE, //MP<4D>˺<EFBFBD>
#endif
#ifdef _SKILL_WILDVIOLENT_ATT
PETSKILL_WILDVIOLENTATTACK, //(540)<29>񱩹<EFBFBD><F1B1A9B9><EFBFBD> vincent add 2002/05/16
#endif
#ifdef _SKILL_SPEEDY_ATT
PETSKILL_SPEEDYATTACK, //(541)<29><><EFBFBD>ٹ<EFBFBD><D9B9><EFBFBD> vincent add 2002/05/16
#endif
#ifdef _SKILL_GUARDBREAK2
PETSKILL_GUARDBREAK2, //(542)<29>Ƴ<EFBFBD><C6B3><EFBFBD><EFBFBD><EFBFBD>2 vincent add 2002/05/20
#endif
#ifdef _SKILL_SACRIFICE
PETSKILL_SACRIFICE, //(543)<29><>Ԯ vincent add 2002/05/30
#endif
#ifdef _SKILL_WEAKEN
PETSKILL_WEAKEN, //(544)<29><>Ԯ vincent add 2002/07/11
#endif
#ifdef _SKILL_DEEPPOISON
PETSKILL_DEEPPOISON, //(545)<29><>Ԯ vincent add 2002/07/16
#endif
#ifdef _SKILL_BARRIER
PETSKILL_BARRIER, //(546)ħ<><C4A7> vincent add 2002/07/16
#endif
#ifdef _SKILL_NOCAST
PETSKILL_NOCAST, //(547)<29><>Ĭ vincent add 2002/07/16
#endif
#ifdef _SKILL_ROAR
PETSKILL_ROAR, //(548)<29><><EFBFBD><EFBFBD> vincent add 2002/07/11
#endif
#ifdef _SKILL_REFRESH
PETSKILL_REFRESH, //(550)<29><>Ԯ vincent add 2002/08/08
#endif
#ifdef _VARY_WOLF
PETSKILL_VARY,
#endif
#ifdef _PETSKILL_SETDUCK
PETSKILL_SETDUCK,
#endif
#ifdef _MAGICPET_SKILL
PETSKILL_SETMAGICPET,
#endif
#ifdef _PETSKILL_BECOMEPIG
PETSKILL_BECOMEPIG,
#endif
#ifdef _PETSKILL_LER
PETSKILL_BATFLY,
PETSKILL_DIVIDEATTACK,
#endif
#ifdef _PETSKILL_BATTLE_MODEL
PETSKILL_BATTLE_MODEL,
#endif
};
static int gymbody[] = {
SPR_001em,SPR_011em,SPR_021em,SPR_031em,SPR_041em,SPR_051em,
SPR_061em,SPR_071em,SPR_081em,SPR_091em,SPR_101em,SPR_111em,
SPR_002em,SPR_012em,SPR_022em,SPR_032em,SPR_042em,SPR_052em,
SPR_062em,SPR_072em,SPR_082em,SPR_092em,SPR_102em,SPR_112em,
SPR_003em,SPR_013em,SPR_023em,SPR_033em,SPR_043em,SPR_053em,
SPR_063em,SPR_073em,SPR_083em,SPR_093em,SPR_103em,SPR_113em,
SPR_004em,SPR_014em,SPR_024em,SPR_034em,SPR_044em,SPR_054em,
SPR_064em,SPR_074em,SPR_084em,SPR_094em,SPR_104em,SPR_114em,
};
/*------------------------------------------------------------------------
* ENEMY<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD>ĸةئ ëܸ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
*-----------------------------------------------------------------------*/
int ENEMY_RandomChange( int enemyindex, int tempno )
{
int work, work2, iRet = 0;
// <20>¼<EFBFBD>ĸةƽ<D8A9>ҷ¾<D2B7><C2BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if( ( 564 <= tempno && tempno <= 580 )
|| ( 739 <= tempno && tempno <= 750 )
|| ( 895 <= tempno && tempno <= 906 )
){
//********************************************
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ
//********************************************
iRet = 1;
}else
// <20>¼<EFBFBD>ĸةƽ<D8A9>ҷ¾<D2B7><C2BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if( ( 655 <= tempno && tempno <= 720 )
|| ( 859 <= tempno && tempno <= 894 )
|| ( 907 <= tempno && tempno <= 940 )
){
//********************************************
// ʸ<><CAB8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ
//********************************************
iRet = 2;
}else{
return 0;
}
if( iRet == 1 ){
//********************************************
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿ<EFBFBD><D3BF><EFBFBD>׳<EFBFBD>ئ<EFBFBD><D8A6>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ¼<D6B7>ĸة
//
//********************************************
// ϳ<>ַ¼<D6B7>ĸة
CHAR_setInt( enemyindex, CHAR_BASEBASEIMAGENUMBER,
gymbody[RAND( 0, arraysizeof( gymbody ) - 1)] );
CHAR_setInt( enemyindex, CHAR_BASEIMAGENUMBER,
CHAR_getInt( enemyindex, CHAR_BASEBASEIMAGENUMBER ) );
// <20><><EFBFBD>뷴<EFBFBD><EBB7B4><EFBFBD><EFBFBD>
work = ( RAND( 0, 20 ) - 10 ) * 10;
work2 = 100 - ABS( work );
CHAR_setInt( enemyindex, CHAR_EARTHAT, work );
CHAR_setInt( enemyindex, CHAR_FIREAT, -work );
if( RAND( 0, 1 ) ){
work2 *= -1;
}
CHAR_setInt( enemyindex, CHAR_WATERAT, work2 );
CHAR_setInt( enemyindex, CHAR_WINDAT, -work2 );
// <20>¼<EFBFBD>ĸةئ տë <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if( DoujyouRandomWeponSet( enemyindex ) ){
// <20><> տ<><D5BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɧ<EFBFBD><C9A7> <20><>ë<EFBFBD><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CHAR_setPetSkill( enemyindex, 0, PETSKILL_NORMALATTACK );
CHAR_setPetSkill( enemyindex, 1, PETSKILL_NORMALATTACK );
}else{
// <20><> տԪ<D5BF><D4AA>ئ<EFBFBD>м<EFBFBD>ƥ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ë<><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CHAR_setPetSkill( enemyindex, 0,
EnemyGymSkill[RAND( 0, arraysizeof( EnemyGymSkill ) - 1 )] );
// ë<><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CHAR_setPetSkill( enemyindex, 1,
EnemyGymSkill[RAND( 0, arraysizeof( EnemyGymSkill ) - 1 )] );
}
}else
if( iRet == 2 ){
// <20><> տԪ<D5BF><D4AA>ئ<EFBFBD>м<EFBFBD>ƥ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ë<><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CHAR_setPetSkill( enemyindex, 0,
EnemyGymSkill[RAND( 0, arraysizeof( EnemyGymSkill ) - 1 )] );
// ë<><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
CHAR_setPetSkill( enemyindex, 1,
EnemyGymSkill[RAND( 0, arraysizeof( EnemyGymSkill ) - 1 )] );
}
return 1;
}
/*------------------------------------------------------------------------
* ENEMY_enemy<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƽ<EFBFBD>ҷ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ë<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>£<EFBFBD>
*-----------------------------------------------------------------------*/
int ENEMY_createEnemy( int array, int baselevel )
{
Char CharNew;
int newindex;
int *p;
int tp[E_T_DATAINTNUM];
int tarray, i;
int itemindex,iloop;
int level;
int enemyrank;
if( !ENEMY_CHECKINDEX( array)) return -1;
p = ENEMY_enemy[array].intdata;
tarray = ENEMYTEMP_getEnemyTempArray( array);
if( !ENEMYTEMP_CHECKINDEX( tarray)) return -1;
// tp = ENEMYTEMP_enemy[tarray].intdata;
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for( i = 0; i < E_T_DATAINTNUM; i ++ ){
tp[i] = ENEMYTEMP_enemy[tarray].intdata[i];
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
memset( &CharNew, 0, sizeof( Char ) );
if( !CHAR_getDefaultChar( &CharNew,31010 ) )return -1;
/* <20><> į */
CharNew.data[CHAR_BASEBASEIMAGENUMBER]
= CharNew.data[CHAR_BASEIMAGENUMBER] = *(tp+E_T_IMGNUMBER);
/* <20><>ƥؤ<C6A5><D8A4><EFBFBD><EFBFBD>ɬ<EFBFBD><C9AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
CharNew.data[CHAR_WHICHTYPE] = CHAR_TYPEENEMY;
/* ë<><C3AB><EFBFBD><EFBFBD> */
CharNew.data[CHAR_DUELPOINT] = 0;
/* <20><>ì<EFBFBD><C3AC>ë<EFBFBD><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>£<EFBFBD> */
if( baselevel > 0 ){
level = baselevel; // <20><>ì<EFBFBD><C3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}else{
level = RAND( (*(p + ENEMY_LV_MIN)), (*(p+ ENEMY_LV_MAX)));
}
#define E_PAR( a) (*(p + (a)))
#define ET_PAR( a) (*(tp + (a)))
/* <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD>Ѿ<EFBFBD><D1BE><EFBFBD> <20>˼<EFBFBD><CBBC><EFBFBD> <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߼<EFBFBD><DFBC><EFBFBD>ңֿ */
#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
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ի<EFBFBD><D4BB>Ի<EFBFBD><D4BB><EFBFBD>̼<EFBFBD><CCBC><EFBFBD><EFBFBD>士<EFBFBD><E5A3AB>ë<EFBFBD>¼<EFBFBD>ĸةƥ<D8A9>浤 */
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;
/* <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƥ<EFBFBD><C6A5>Ի<EFBFBD><D4BB>Ի<EFBFBD><D4BB><EFBFBD>̼<EFBFBD><CCBC><EFBFBD>ë<EFBFBD><C3AB><EFBFBD><EFBFBD><EFBFBD>ƻ<EFBFBD><C6BB><EFBFBD><EFBFBD><EFBFBD> */
CharNew.data[CHAR_ALLOCPOINT]
= ( tp[E_T_BASEVITAL] << 24 )
+ ( tp[E_T_BASESTR] << 16 )
+ ( tp[E_T_BASETGH] << 8 )
+ ( tp[E_T_BASEDEX] << 0 );
/* <20><><EFBFBD><EFBFBD> <20><><EFBFBD>¼<EFBFBD>ĸةƥ<D8A9><C6A5><EFBFBD>̼<EFBFBD><CCBC><EFBFBD>ë<EFBFBD><C3AB><EFBFBD>𹴵<EFBFBD>ң<EFBFBD>۳<EFBFBD>ľë<C4BE><C3AB><EFBFBD>߼<EFBFBD><DFBC><EFBFBD>Ի߯<D4BB>ʣ<EFBFBD>*/
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]++;
}
/* <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
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_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_SLOT] = *(tp+ E_T_SLOT);
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);
CharNew.data[CHAR_PETENEMYID] = ENEMY_getInt( array, ENEMY_ID);
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
CharNew.data[CHAR_DUELPOINT] = *( p + ENEMY_DUELPOINT);
if( *( p + ENEMY_DUELPOINT) <= 0 ) {
if( *(p + ENEMY_EXP) != -1 ) {
CharNew.data[CHAR_EXP] = *( p+ENEMY_EXP);
}else {
CharNew.data[CHAR_EXP] = ENEMY_getExp( array,tarray,level, enemyrank);
}
}
strcpysafe( CharNew.string[CHAR_NAME].string,
sizeof(CharNew.string[CHAR_NAME].string),
(char *)ENEMYTEMP_enemy[tarray].chardata[E_T_NAME].string );
newindex = CHAR_initCharOneArray( &CharNew );
#ifdef _CAX_LVTISHI
if (CHAR_getInt( newindex, CHAR_LV) == 1){//<2F><><EFBFBD><EFBFBD>
char buff[256];
snprintf( buff, sizeof( buff),"%s<><73><EFBFBD><EFBFBD>",CHAR_getChar( newindex, CHAR_NAME));
CHAR_setChar( newindex, CHAR_NAME, buff);
}
#endif
if( newindex < 0 ){
return -1;
}
for( iloop=0; iloop< (ENEMY_ITEMPROB10 - ENEMY_ITEM1+1)/2; iloop++){
if( *(p+ENEMY_ITEMPROB1+iloop) != 0) {
#ifdef _FIX_ITEMPROB
if( RAND( 0,999) < *(p+ENEMY_ITEMPROB1+iloop)){
#else
if( RAND( 0,99) < *(p+ENEMY_ITEMPROB1+iloop)){
#endif
itemindex = ITEM_makeItemAndRegist( *(p+ENEMY_ITEM1+iloop) );
CHAR_setItemIndex( newindex, CHAR_STARTITEMARRAY +iloop, itemindex);
ITEM_setWorkInt( itemindex, ITEM_WORKCHARAINDEX, newindex );
ITEM_setWorkInt( itemindex, ITEM_WORKOBJINDEX,-1);
}
}
}
{ int style, wepon = -1;
style = (*(p + ENEMY_STYLE));
switch( style ){
case 1: wepon = 0;break; //
case 2: wepon = 100;break; // <20><><EFBFBD><EFBFBD>
case 3: wepon = 200;break; // <20><>
case 4: wepon = 400;break; // <20><>
case 5: wepon = 500;break; // Ƥ<><C6A4><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD>
case 6: wepon = 700;break; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
case 7: wepon = 600;break; // <20><><EFBFBD><EFBFBD>
default:break;
}
if( wepon >= 0 ){
itemindex = ITEM_makeItemAndRegist( wepon ) ;
CHAR_setItemIndex( newindex, CHAR_ARM, itemindex );
ITEM_setWorkInt( itemindex, ITEM_WORKCHARAINDEX, newindex );
ITEM_setWorkInt( itemindex, ITEM_WORKOBJINDEX,-1);
}
}
ENEMY_RandomChange( newindex, *( p+ENEMY_ID) );
CHAR_complianceParameter( newindex );
CHAR_setInt( newindex, CHAR_HP, CHAR_getWorkInt( newindex, CHAR_WORKMAXHP));
CHAR_setWorkInt( newindex, CHAR_WORKTACTICS, *(p+ENEMY_TACTICS));
CHAR_setWorkChar( newindex, CHAR_WORKBATTLE_TACTICSOPTION,
ENEMY_enemy[array].chardata[ENEMY_TACTICSOPTION].string );
#ifdef _BATTLENPC_WARP_PLAYER
CHAR_setWorkChar( newindex, CHAR_WORKBATTLE_ACT_CONDITION,
ENEMY_enemy[array].chardata[ENEMY_ACT_CONDITION].string );
#endif
CHAR_setWorkInt( newindex, CHAR_WORK_PETFLG, *(p+ENEMY_PETFLG));
CHAR_setWorkInt( newindex, CHAR_WORKMODCAPTUREDEFAULT, *(tp + E_T_GET));
#ifdef _ENEMY_FALLGROUND
{
int i=0;
for( i=0;i<arraysizeof( ridePetTable);i++) {
if( CHAR_getInt( newindex, CHAR_BASEBASEIMAGENUMBER) == ridePetTable[i].rideNo ) {
CHAR_setInt( newindex, CHAR_BASEBASEIMAGENUMBER, ridePetTable[i].charNo );
CHAR_setInt( newindex, CHAR_BASEIMAGENUMBER, ridePetTable[i].rideNo );
break;
}
}
}
#endif
#ifdef _PETSKILL_BECOMEFOX //<2F><><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ-1
CHAR_setWorkInt( newindex, CHAR_WORKFOXROUND, -1 );
#endif
return newindex;
}
#define RANDOMENEMY_TOP 945
#define RANDOMENEMY_END 956
static int RandomHuman945[] = {739,742,745,748};
static int RandomPet946[] = {859,860,861,868,869,870,881,882,883,884};
static int RandomPet964[] = {859,860,861,868,869,870,881,882,883,884};
static int RandomHuman947[] = {740,743,746,749};
static int RandomPet948[] = {864,871,872,873,885,886,889,890,891,892,893,894};
static int RandomPet965[] = {864,871,872,873,885,886,889,890,891,892,893,894};
static int RandomHuman949[] = {741,744,747,750};
static int RandomPet950[] = {862,863,865,866,867,874,875,876,877,878,879,880};
static int RandomPet966[] = {862,863,865,866,867,874,875,876,877,878,879,880};
static int RandomHuman951[] = {895,898,901,904};
static int RandomPet952[] = {912,913,914,915,916,917,918,919,920,928};
static int RandomPet967[] = {912,913,914,915,916,917,918,919,920,928};
static int RandomHuman953[] = {896,899,902,905};
static int RandomPet954[] = {929,930,931,932,933,934,935,936,937,938,939,940};
static int RandomPet968[] = {929,930,931,932,933,934,935,936,937,938,939,940};
static int RandomHuman955[] = {897,900,903,906};
static int RandomPet956[] = {907,908,909,910,911,921,922,923,924,925,926,927};
static int RandomPet969[] = {907,908,909,910,911,921,922,923,924,925,926,927};
typedef struct {
int num;
int *pTbl;
int arraysize;
}RANDOMENEMY;
static RANDOMENEMY RandomEnemyTbl[] = {
{ 945, RandomHuman945, arraysizeof( RandomHuman945 ) },
{ 946, RandomPet946, arraysizeof( RandomPet946 ) },
{ 947, RandomHuman947, arraysizeof( RandomHuman947 ) },
{ 948, RandomPet948, arraysizeof( RandomPet948 ) },
{ 949, RandomHuman949, arraysizeof( RandomHuman949 ) },
{ 950, RandomPet950, arraysizeof( RandomPet950 ) },
{ 951, RandomHuman951, arraysizeof( RandomHuman951 ) },
{ 952, RandomPet952, arraysizeof( RandomPet952 ) },
{ 953, RandomHuman953, arraysizeof( RandomHuman953 ) },
{ 954, RandomPet954, arraysizeof( RandomPet954 ) },
{ 955, RandomHuman955, arraysizeof( RandomHuman955 ) },
{ 956, RandomPet956, arraysizeof( RandomPet956 ) },
{ 964, RandomPet964, arraysizeof( RandomPet964 ) },
{ 965, RandomPet965, arraysizeof( RandomPet965 ) },
{ 966, RandomPet966, arraysizeof( RandomPet966 ) },
{ 967, RandomPet967, arraysizeof( RandomPet967 ) },
{ 968, RandomPet968, arraysizeof( RandomPet968 ) },
{ 969, RandomPet969, arraysizeof( RandomPet969 ) },
};
/*------------------------------------------------------------
* <EFBFBD><EFBFBD> ɬ<EFBFBD>ü<EFBFBD>ġ į<EFBFBD><EFBFBD> <EFBFBD><EFBFBD>ئ<EFBFBD><EFBFBD>ئ<EFBFBD>շ¼<EFBFBD>ĸة<EFBFBD><EFBFBD>ɬ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
------------------------------------------------------------*/
int ENEMY_RandomEnemyArray( int e_array, int *pNew )
{
int i = 0, randwork, work;
// RANDOMENEMY *pRandomEnemy;
*pNew = -1;
// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD>ĸة
if(
( RANDOMENEMY_TOP <= e_array && e_array <= RANDOMENEMY_END )
|| ( 964 <= e_array && e_array <= 969 )
){
// <20><><EFBFBD><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʃ<EFBFBD><C6A9><EFBFBD><EFBFBD>
for( i = 0; i < arraysizeof( RandomEnemyTbl ); i ++ ){
if( RandomEnemyTbl[i].num == e_array ){
break;
}
}
// <20><>ë<EFBFBD><C3AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>վ޷¡<DEB7>ƥ <20><><EFBFBD><EFBFBD>
if( i >= arraysizeof( RandomEnemyTbl ) ) return 0;
// <20>¼<EFBFBD>ĸةɬ<D8A9><C9AC>
randwork = RAND( 0, RandomEnemyTbl[i].arraysize - 1 );
// <20><><EFBFBD><EFBFBD>ޥ<EFBFBD><DEA5><EFBFBD><EFBFBD> įë<C4AF><C3AB>
work = RandomEnemyTbl[i].pTbl[randwork];
*pNew = ENEMY_getEnemyArrayFromId( work );
return 1;
}else{
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ئ<EFBFBD><D8A6>
return 0;
}
}
int *ENEMY_getEnemy( int charaindex, int x, int y)
{
int i;
int array;
int g_array;
int e_array;
int found = 0;
int work[ENEMY_INDEXTABLEMAXSIZE];
int wr[ENEMY_INDEXTABLEMAXSIZE];
int createenemynum;
int enemyentrymax;
int entrymax;
int r_max;
int groupid;
int bigcnt;
int loopcounter;
array = ENCOUNT_getEncountAreaArray( CHAR_getInt( charaindex, CHAR_FLOOR),x,y);
if( array == -1 ) return NULL;
enemyentrymax = ENCOUNT_getCreateEnemyMaxNumFromArray( array);
if( enemyentrymax == -1 ) {
return NULL;
}
for( i = 0 ; i < ENEMY_INDEXTABLEMAXSIZE; i ++ ) {
work[i] = -1;
wr[i] = -1;
ENEMY_indextable[i] = -1;
}
r_max= 0;
for( i = 0; i < ENCOUNT_GROUPMAXNUM; i ++ ){
if( ENCOUNT_getGroupIdFromArray( array, i ) != - 1 ) {
int itemid;
groupid = ENCOUNT_getGroupIdFromArray( array, i);
g_array = GROUP_getGroupArray( groupid);
itemid = GROUP_getInt( g_array, GROUP_APPEARBYITEMID);
if( itemid != -1 ) {
int j;
for( j = 0; j < CHAR_MAXITEMHAVE; j ++ ) {
int itemindex = CHAR_getItemIndex( charaindex, j);
if( ITEM_CHECKINDEX( itemindex)) {
if( ITEM_getInt( itemindex, ITEM_ID) == itemid){
break;
}
}
}
if( j == CHAR_MAXITEMHAVE ) continue;
}
itemid = GROUP_getInt( g_array, GROUP_NOTAPPEARBYITEMID);
if( itemid != -1 ) {
int j;
for( j = 0; j < CHAR_MAXITEMHAVE; j ++ ) {
int itemindex = CHAR_getItemIndex( charaindex, j);
if( ITEM_CHECKINDEX( itemindex)) {
if( ITEM_getInt( itemindex, ITEM_ID) == itemid){
break;
}
}
}
if( j != CHAR_MAXITEMHAVE ) continue;
}
work[found] = i;
wr[found] = ENCOUNT_getGroupProbFromArray( array, i);
r_max += wr[found];
found ++;
}
}
r_max --;
if( found <= 0 ) return NULL;
{
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 <20><><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>޼<EFBFBD>
{
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]++;
}
/* <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
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);
CharNew.data[CHAR_PETENEMYID] = ENEMY_getInt( array, ENEMY_ID);
// Arminius 8.6 limit lv
CharNew.data[CHAR_LIMITLEVEL] = *(tp + E_T_LIMITLEVEL);
#ifdef _PET_FUSION
CharNew.data[CHAR_FUSIONCODE] = *(tp + E_T_FUSIONCODE);
#endif
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;
}
int ENEMY_createPet( int array, int vital, int str, int tgh, int dex)
{
Char CharNew;
int newindex;
int *p;
int tp[E_T_DATAINTNUM];
int tarray, i;
int level;
int enemyrank;
if( !ENEMY_CHECKINDEX( array)) 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;
#ifdef _BT_PET
tp[E_T_BASEVITAL]*= getBtPet();
tp[E_T_BASESTR]*= getBtPet();
tp[E_T_BASETGH]*= getBtPet();
tp[E_T_BASEDEX]*= getBtPet();
#endif
if(vital > -1){
tp[E_T_BASEVITAL] = vital;
}
if(str > -1){
tp[E_T_BASESTR] = str;
}
if(tgh > -1){
tp[E_T_BASETGH] = tgh;
}
if(dex > -1){
tp[E_T_BASEDEX] = dex;
}
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]++;
}
/* <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
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);
#ifdef _PET_FUSION
CharNew.data[CHAR_FUSIONCODE] = *(tp + E_T_FUSIONCODE);
#endif
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, -1);
return newindex;
}
int ENEMY_createPetFromEnemyBaseIndex( int charaindex, int array, int level )
{
Char CharNew;
int newindex;
//int *p;
int tp[E_T_DATAINTNUM];
int tarray, i;
int havepetelement;
//int level;
int enemyrank;
/*
#ifdef _LF_FIX_ERROR_PET_CREATE
if( !ENEMY_getUse(array) ) return -1;
#else
if( !ENEMY_CHECKINDEX( array)) return -1;
#endif
*/
havepetelement = CHAR_getCharPetElement( charaindex);
if( havepetelement < 0 ) return -1;
//p = ENEMY_enemy[array].intdata;
tarray = ENEMYTEMP_getEnemyTempArrayFromTempNo( array);
tarray = array;
#ifdef _LF_FIX_ERROR_PET_CREATE
if( !ENEMYTEMP_getUse(tarray) ) return -1;
#else
if( !ENEMYTEMP_CHECKINDEX( tarray)) return -1;
#endif
// 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;
#ifdef _FIX_DEX_BUG
tp[E_T_BASEDEX] += RAND( 2, 4 ) - 2;
#else
tp[E_T_BASEDEX] += RAND( 0, 4 ) - 2;
#endif
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]++;
}
/* <20>ɷ¶<C9B7><C2B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> */
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);
#ifdef _PET_FUSION
CharNew.data[CHAR_FUSIONCODE] = *(tp + E_T_FUSIONCODE);
#endif
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);
CharNew.data[CHAR_PETENEMYID] = ENEMY_getInt( array, ENEMY_ID);
// Arminius 8.6 limit lv
CharNew.data[CHAR_LIMITLEVEL] = *(tp + E_T_LIMITLEVEL);
#ifdef _PET_FUSION
CharNew.data[CHAR_FUSIONCODE] = *(tp + E_T_FUSIONCODE);
#endif
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 );
#ifdef _CAX_LVTISHI
if (CHAR_getInt( newindex, CHAR_LV) == 1){//<2F><><EFBFBD><EFBFBD>
char buff[256];
snprintf( buff, sizeof( buff),"%s<><73><EFBFBD><EFBFBD>",CHAR_getChar( newindex, CHAR_NAME));
CHAR_setChar( newindex, CHAR_NAME, buff);
}
#endif
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_EVOLUTION
BOOL PETFUSION_getIndexForChar( int toindex, int *MainIndex, int *Subindex1, int *Subindex2, char *data)
{
char buf1[256];
int pindex[3]={-1,-1,-1};
int i;
int ridepet=CHAR_getInt( toindex , CHAR_RIDEPET);
int rideindex = CHAR_getCharPet( toindex,ridepet);
if( getStringFromIndexWithDelim( data, "|", 1, buf1, sizeof(buf1)) == FALSE )
return FALSE;
pindex[0] = atoi( buf1)-1;
if( getStringFromIndexWithDelim( data, "|", 2, buf1, sizeof(buf1)) == FALSE )
return FALSE;
pindex[1] = atoi( buf1)-1;
if( getStringFromIndexWithDelim( data, "|", 3, buf1, sizeof(buf1)) == FALSE )
return FALSE;
pindex[2] = atoi( buf1)-1;
for( i=0; i<3; i++) {
int petindex;
if( pindex[i] < 0 ) continue;
petindex = CHAR_getCharPet( toindex, pindex[i]);
if( !CHAR_CHECKINDEX( petindex) ) continue;
#ifdef _CAX_PET_EVOLUTION
if( getpetevotyb() == 0 ){
#endif
#ifdef _PET_2TRANS
if( CHAR_getInt( petindex, CHAR_TRANSMIGRATION ) ==2){
CHAR_talkToCli( toindex, -1, "<EFBFBD><EFBFBD>ת<EFBFBD><EFBFBD><EFBFBD>ﲻ<EFBFBD><EFBFBD><EFBFBD>ںϡ<EFBFBD>", CHAR_COLORYELLOW);
return FALSE;
}
#endif
#ifdef _CAX_PET_EVOLUTION
}
if( CHAR_getInt( petindex, CHAR_TRANSMIGRATION ) == 3 ) {
CHAR_talkToCli( toindex, -1, "<EFBFBD><EFBFBD>ת<EFBFBD><EFBFBD><EFBFBD>ﲻ<EFBFBD><EFBFBD><EFBFBD>ںϡ<EFBFBD>", CHAR_COLORYELLOW);
return FALSE;
}
#endif
if( rideindex == petindex) {
CHAR_talkToCli( toindex, -1, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еij費<EFBFBD><EFBFBD><EFBFBD>ںϡ<EFBFBD>", CHAR_COLORYELLOW);
return FALSE;
}
if( i == 0 ) {
*MainIndex = petindex;
}else if( i == 1) {
*Subindex1 = petindex;
}else if( i == 2) {
*Subindex2 = petindex;
}
}
return TRUE;
}
int NPC_getPetArrayForNo( int PetCode)
{
int i;
int enemynum = ENEMY_getEnemyNum();
for( i = 0; i < enemynum; i ++ ) {//PetCode
if( ENEMY_getInt( i, ENEMY_TEMPNO ) == PetCode )
break;
}
if( i == enemynum ){
print("ANDY 2.err i == enemynum \n");
return -1;
}
return i;
}
int NPC_getFusionTableForBase( int charaindex, int petindex1, int petindex2 )
{
int base1, base2;// <20><><EFBFBD><EFBFBD>,PETCODE
if( !CHAR_CHECKINDEX( petindex1) ) return -1;
if( !CHAR_CHECKINDEX( petindex2) ) return -1;
#ifdef _PET_EVOLUTION
if( (base2 = EVOLUTION_getPetTable( charaindex, petindex1, petindex2)) < 0 ){
print("ANDY err base2=%d\n", base2);
return -1;
}
if( (base1 = EVOLUTION_getPropertyTable( charaindex, petindex1, petindex2)) < 0 ){
print("ANDY err base1=%d\n", base1);
return -1;
}
return EVOLUTION_getFusionTable( charaindex, base2, base1); // get new pet IDNO
#else
return -1;
#endif
}
BOOL PET_getEvolutionAns( int petindex, int *base)
{
int i, total1, total2, total;
#ifdef _CAX_PET_EVOLUTION
int defwork = 50, defbase = getpetevotyb1();
#else
int defwork = 50, defbase = 150;
#endif
int work[4]={0,0,0,0};
work[0] = CHAR_getInt( petindex, CHAR_EVOLUTIONBASEVTL);
work[1] = CHAR_getInt( petindex, CHAR_EVOLUTIONBASESTR);
work[2] = CHAR_getInt( petindex, CHAR_EVOLUTIONBASETGH);
work[3] = CHAR_getInt( petindex, CHAR_EVOLUTIONBASEDEX);
for( i=0; i<4; i++) {
work[i] = (work[i]*0.7)/100;
if( work[i]<0 ) work[i] = 0;
if( work[i]>60 ) work[i] = 60;
}
total1 = work[0] + work[1] + work[2] + work[3];
for( i=0; i<4; i++) {
if( base[i] < 0 ) base[i] = 5;
if( base[i] > 60 ) base[i] = 60;
}
total2 = base[0] + base[1] + base[2] + base[3];
if( total1 > defwork ) {
for( i=0; i<4; i++) {
work[i] = ((work[i]*defwork)/total1);
if( work[i]<0 ) work[i] = 0;
if( work[i]>60 ) work[i] = 60;
}
}
total1 = work[0] + work[1] + work[2] + work[3];
total = (total1/2) + total2;
if( total > 0 ){
for( i=0; i<4; i++) {
float fixwork=0.0;
fixwork = (base[i])+(float)(work[i]/2);
base[i] += (int)((fixwork/total) * total1);
if( base[i] < 1 ) base[i] = 1;
if( base[i] > 60 ) base[i] = 60;
}
}
total2 = base[0] + base[1] + base[2] + base[3];
if( total2 > defbase ){
for( i=0; i<4; i++) {
base[i] = (base[i]*defbase)/total2;
if( base[i] < 1 ) base[i] = 1;
if( base[i] > 60 ) base[i] = 60;
}
}
total2 = base[0] + base[1] + base[2] + base[3];
if( base[0]<0 || base[1]<0 || base[2]<0 || base[3]<0 ){
print("ANDY err EVOLUTION base someone < 0 !!\n");
}
return TRUE;
}
int EVOLUTION_createPetFromEnemyIndex( int charaindex, int baseindex, int flg)
{
Char CharNew;
int newindex;
int *p;
int tp[E_T_DATAINTNUM];
int tarray, i, havepetelement, enemynum, petID;
int level, enemyrank, array;
int petskill[7]={-1,-1,-1,-1,-1,-1,-1};
int base[4]={0,0,0,0};
#ifdef _illegalpetskill_CF
int illegalpetskill[25] = {41,52,600,601,602,603,604,614,617,628,630,631,635,638,641,
getIllegalPetskill(0),getIllegalPetskill(1),getIllegalPetskill(2),getIllegalPetskill(3),getIllegalPetskill(4),
getIllegalPetskill(5),getIllegalPetskill(6),getIllegalPetskill(7),getIllegalPetskill(8),getIllegalPetskill(9)};//<2F>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>ֹ<EFBFBD>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD>＼<EFBFBD><EFBCBC>
#else
int illegalpetskill[15] = {41,52,600,601,602,603,604,614,617,628,630,631,635,638,641};//<2F><><EFBFBD><EFBFBD><EFBFBD>Ŵ<EFBFBD><C5B4>ij輼
#endif
#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)) * ET_PAR( (l))
havepetelement=-1;
petID = CHAR_getInt( baseindex, CHAR_FUSIONINDEX);
enemynum = ENEMY_getEnemyNum();
for( i = 0; i < enemynum; i ++ ) {
if( ENEMY_getInt( i, ENEMY_TEMPNO ) == petID ){
break;
}
}
if( i >= enemynum ) return -1;
array = i;
if( !ENEMY_CHECKINDEX( array)) return -1;
//--------------------------------------------------------------------------
p = ENEMY_enemy[array].intdata;
tarray = ENEMYTEMP_getEnemyTempArray( array);
if( !ENEMYTEMP_CHECKINDEX( tarray)){
print( "ANDY !tarray\n");
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 ) ){
print( "ANDY !CHAR_getDefaultChar( &CharNew,31010 )\n");
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)));
//------------------------------------------------------
{
if( PET_getBaseAndSkill( charaindex, baseindex, base, petskill, 1) == FALSE ){
print( "ANDY err PET_getBaseAndSkill(%d) == FALSE \n", baseindex);
return -1;
}
if( PET_getEvolutionAns( baseindex, base) == FALSE ) return -1;
for( i=0; i < CHAR_MAXPETSKILLHAVE; i ++ ) {//<2F>輼
int j;
for( j=0; j<15; j++) { //<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
if( illegalpetskill[j] == petskill[i] ){
petskill[i] = -1;
break;
}
}
CharNew.unionTable.indexOfPetskill[i] = petskill[i];
}
if( flg == 1 ){
if( CHAR_DelPetForIndex( charaindex, baseindex) == FALSE ) return FALSE;
}
}
if( flg == 1 ){
havepetelement = CHAR_getCharPetElement( charaindex);//<2F>ҳ<EFBFBD><D2B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ
if( havepetelement < 0 ) return -1;
}
//------------------------------------------------------
tp[E_T_BASEVITAL] = base[0];
tp[E_T_BASESTR] = base[1];
tp[E_T_BASETGH] = base[2];
tp[E_T_BASEDEX] = base[3];
CharNew.data[CHAR_ALLOCPOINT] = (base[0]<<24)+(base[1]<<16)+(base[2]<<8)+(base[3]<<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);
CharNew.data[CHAR_LIMITLEVEL] = *(tp + E_T_LIMITLEVEL);
CharNew.data[CHAR_FUSIONCODE] = *(tp + E_T_FUSIONCODE);
CharNew.data[CHAR_PETMAILEFFECT] = RAND(0, PETMAIL_EFFECTMAX);
//------------------------------------------------------
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 ){
print( "ANDY err newindex=%d\n", newindex);
return -1;
}
//------------------------------------------------------
CHAR_complianceParameter( newindex );
CHAR_setInt( newindex, CHAR_HP, CHAR_getWorkInt( newindex, CHAR_WORKMAXHP));
CHAR_setInt ( newindex, CHAR_WHICHTYPE , CHAR_TYPEPET);
#ifdef _PET_2TRANS
#ifdef _PET_3TRANS
CHAR_setInt ( newindex, CHAR_TRANSMIGRATION, 3);
#else
CHAR_setInt ( newindex, CHAR_TRANSMIGRATION, 2);
#endif
#else
CHAR_setInt ( newindex, CHAR_TRANSMIGRATION, 1);
#endif
CHAR_setInt ( newindex, CHAR_FUSIONBEIT, 1);
CHAR_setInt ( newindex, CHAR_FUSIONRAISE, 0);
if( flg == 1 ){
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));
{
char msgbuf[256];
snprintf( msgbuf, sizeof( msgbuf ), "K%d", havepetelement );
CHAR_sendStatusString( charaindex, msgbuf );
snprintf( msgbuf, sizeof( msgbuf ), "W%d", havepetelement );
CHAR_sendStatusString( charaindex, msgbuf );
}
}
return newindex;
}
int PET_CheckIncubate( int charaindex)
{
#ifndef _USER_CHARLOOPS
int i;
static time_t checkeage;
int anhour = PETFEEDTIME;
checkeage = (int)time( NULL);
if( !CHAR_CHECKINDEX( charaindex) )return 0;
for(i=0 ; i < CHAR_MAXPETHAVE ; i++) {
int time_l=0;
int petindex = CHAR_getCharPet( charaindex, i);
if( !CHAR_CHECKINDEX( petindex) ) continue;
if( CHAR_getInt( petindex, CHAR_FUSIONBEIT) != 1 ||
CHAR_getInt( petindex, CHAR_FUSIONRAISE) <= 0 )return;//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Ϊ<EFBFBD>ںϳ<DABA>
time_l = CHAR_getInt( petindex, CHAR_FUSIONTIMELIMIT);
if( time_l < 0 || time_l > checkeage ){
CHAR_setInt( petindex, CHAR_FUSIONTIMELIMIT, checkeage);
continue;
}
if( (int)checkeage > (time_l+(anhour*2)) ){
char buf[256];
int levelup, vital, str, tgh, dex;
int raise = CHAR_getInt( petindex, CHAR_FUSIONRAISE);
//ι<><CEB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
raise++;
CHAR_setInt( petindex, CHAR_FUSIONTIMELIMIT, (int)time(NULL)+anhour-1);
if( raise < 0 ) raise = 0;
if( raise >= 40 ) raise = 30;
CHAR_setInt( petindex, CHAR_FUSIONRAISE, raise);
levelup = CHAR_getInt( petindex, CHAR_ALLOCPOINT);
vital = ((levelup>>24) & 0xFF) - 5;
str = ((levelup>>16) & 0xFF) - 5;
tgh = ((levelup>> 8) & 0xFF) - 5;
dex = ((levelup>> 0) & 0xFF) - 5;
if( vital < 0 ) vital = 0;
if( str < 0 ) str = 0;
if( tgh < 0 ) tgh = 0;
if( dex < 0 ) dex = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
levelup = (vital<<24) + (str<<16) + (tgh<<8) + (dex<<0);
CHAR_setInt( petindex, CHAR_ALLOCPOINT, levelup);
sprintf( buf, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s<><73><EFBFBD><EFBFBD>Ʒ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ˡ<EFBFBD>", CHAR_getUseName( petindex ));
CHAR_talkToCli( charaindex, -1, buf, CHAR_COLORYELLOW);
LogPetFeed(
CHAR_getChar( charaindex, CHAR_NAME),
CHAR_getChar( charaindex, CHAR_CDKEY),
CHAR_getChar( petindex, CHAR_NAME),
petindex,
CHAR_getInt( petindex, CHAR_LV),
"Ʒ<EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD>", // Key
CHAR_getInt( charaindex, CHAR_FLOOR),
CHAR_getInt( charaindex, CHAR_X),
CHAR_getInt( charaindex, CHAR_Y),
CHAR_getChar( petindex, CHAR_UNIQUECODE) );
}else if( (int)checkeage > (time_l+anhour) ){
char buf[256];
sprintf( buf, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s<><73><EFBFBD><EFBFBD><EFBFBD>ֿ<EFBFBD>ιʳ״̬<D7B4><CCAC>", CHAR_getUseName( petindex ));
CHAR_talkToCli( charaindex, -1, buf, CHAR_COLORYELLOW);
}
}
return 1;
#else
int masterindex, time_l=0;
static time_t checkeage;
int anhour = PETFEEDTIME, i;
if( !CHAR_CHECKINDEX( charaindex) )return 0;
masterindex = CHAR_getWorkInt( charaindex, CHAR_WORKPLAYERINDEX);
if( !CHAR_CHECKINDEX( masterindex) )return 0;
if( CHAR_getInt( charaindex, CHAR_FUSIONBEIT) != 1 ||
CHAR_getInt( charaindex, CHAR_FUSIONRAISE) <= 0 ) return 0;//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD>Ϊ<EFBFBD>ںϳ<DABA>
for(i=0 ; i < CHAR_MAXPETHAVE ; i++) {
if( charaindex != CHAR_getCharPet( masterindex, i) ) continue;
break;
}
if( i >= CHAR_MAXPETHAVE ) return 0;
checkeage = (int)time( NULL);
time_l = CHAR_getInt( charaindex, CHAR_FUSIONTIMELIMIT);
if( time_l < 0 || time_l > checkeage ){
CHAR_setInt( charaindex, CHAR_FUSIONTIMELIMIT, checkeage);
return 0;
}
if( (int)checkeage > (time_l+(anhour*2.5)) ){
char buf[256];
int levelup, vital, str, tgh, dex;
int raise = CHAR_getInt( charaindex, CHAR_FUSIONRAISE);
raise++;
CHAR_setInt( charaindex, CHAR_FUSIONTIMELIMIT, (int)time(NULL)+anhour-1);
if( raise < 0 ) raise = 0;
if( raise >= 40 ) raise = 30;
CHAR_setInt( charaindex, CHAR_FUSIONRAISE, raise);
levelup = CHAR_getInt( charaindex, CHAR_ALLOCPOINT);
vital = ((levelup>>24) & 0xFF) - 6;
str = ((levelup>>16) & 0xFF) - 6;
tgh = ((levelup>> 8) & 0xFF) - 6;
dex = ((levelup>> 0) & 0xFF) - 6;
if( vital < 0 ) vital = 0;
if( str < 0 ) str = 0;
if( tgh < 0 ) tgh = 0;
if( dex < 0 ) dex = 0;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
levelup = (vital<<24) + (str<<16) + (tgh<<8) + (dex<<0);
CHAR_setInt( charaindex, CHAR_ALLOCPOINT, levelup);
sprintf( buf, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s<><73><EFBFBD><EFBFBD>Ʒ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>ˡ<EFBFBD>", CHAR_getUseName( charaindex ));
CHAR_talkToCli( masterindex, -1, buf, CHAR_COLORYELLOW);
LogPetFeed(
CHAR_getChar( masterindex, CHAR_NAME),
CHAR_getChar( masterindex, CHAR_CDKEY),
CHAR_getChar( charaindex, CHAR_NAME),
charaindex,
CHAR_getInt( charaindex, CHAR_LV),
"Ʒ<EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD>", // Key
CHAR_getInt( masterindex, CHAR_FLOOR),
CHAR_getInt( masterindex, CHAR_X),
CHAR_getInt( masterindex, CHAR_Y),
CHAR_getChar( charaindex, CHAR_UNIQUECODE) );
}else if( (int)checkeage > (time_l+anhour) ){
char buf[256];
sprintf( buf, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>%s<><73><EFBFBD><EFBFBD><EFBFBD>ֿ<EFBFBD>ιʳ״̬<D7B4><CCAC>", CHAR_getUseName( charaindex ));
CHAR_talkToCli( masterindex, -1, buf, CHAR_COLORYELLOW);
}
return 1;
#endif
}
#endif
#ifdef _NPC_FUSION
int PETFUSION_SetNewEgg( int toindex , int petindex, int array, int *work, int *skill1, int *skill2)
{
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;
//print( "ANDY tarray/array=%d/%d-->%s \n", tarray, array,
// ENEMYTEMP_getChar( tarray, E_T_NAME));
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);
//<2F><><EFBFBD>＼<EFBFBD><EFBCBC><EFBFBD><EFBFBD>Ϊ<EFBFBD>߼<EFBFBD>
CHAR_setInt( petindex, CHAR_SLOT, 7);
{
int j;
#ifdef _illegalpetskill_CF
int illegalpetskill[25] = {41,52,600,601,602,603,604,614,617,628,630,631,635,638,641,
getIllegalPetskill(0),getIllegalPetskill(1),getIllegalPetskill(2),getIllegalPetskill(3),getIllegalPetskill(4),
getIllegalPetskill(5),getIllegalPetskill(6),getIllegalPetskill(7),getIllegalPetskill(8),getIllegalPetskill(9)};//<2F>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>ֹ<EFBFBD>Ŵ<EFBFBD><C5B4><EFBFBD><EFBFBD>＼<EFBFBD><EFBCBC>
#else
int illegalpetskill[15] = {41,52,600,601,602,603,604,614,617,628,630,631,635,638,641};
#endif
for( i=0; i<CHAR_MAXPETSKILLHAVE; i++) {
if( RAND( 0, 1 ) == 0 ) {
skill1[i] = skill2[i];
}
for( j=0; j<15; j++) { //<2F><><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>
if( illegalpetskill[j] == skill1[i] ){
skill1[i] = -1;
break;
}
}
}
}
for( i=0; i<CHAR_MAXPETSKILLHAVE; i++) {
CHAR_setPetSkill( petindex, i, skill1[i]);
}
#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
#ifdef _PET_3TRANS
CHAR_setInt ( petindex, CHAR_TRANSMIGRATION, 3);
#else
CHAR_setInt ( petindex, CHAR_TRANSMIGRATION, 2);
#endif
#else
CHAR_setInt ( petindex, CHAR_TRANSMIGRATION, 1);
#endif
CHAR_setInt( petindex, CHAR_FUSIONCODE, -1);
CHAR_setInt( petindex, CHAR_FUSIONRAISE, 40);
CHAR_setInt( petindex, CHAR_FUSIONBEIT, 1);
CHAR_setInt( petindex, CHAR_FUSIONTIMELIMIT, (int)time(NULL));
CHAR_setInt( petindex, CHAR_EVOLUTIONBASEVTL, 0);
CHAR_setInt( petindex, CHAR_EVOLUTIONBASESTR, 0);
CHAR_setInt( petindex, CHAR_EVOLUTIONBASETGH, 0);
CHAR_setInt( petindex, CHAR_EVOLUTIONBASEDEX, 0);
#ifdef _USER_CHARLOOPS
{
Char *ch;
ch = CHAR_getCharPointer( petindex);
if( ch == NULL ) return 0;
//andy_log
// print("*CHAR_LOOPFUNCTEMP1:%s \n", "PET_CheckIncubateLoop");
strcpysafe( ch->charfunctable[CHAR_LOOPFUNCTEMP1].string,
sizeof( ch->charfunctable[CHAR_LOOPFUNCTEMP1]), "PET_CheckIncubateLoop");
ch->data[CHAR_LOOPINTERVAL] = 60000;
CHAR_constructFunctable( petindex);
}
#endif
if( CHAR_CHECKINDEX( toindex) ){
for(i = 0; i < CHAR_MAXPETHAVE; i++){
char msgbuf[256];
int pindex = CHAR_getCharPet(toindex, i);
if( !CHAR_CHECKINDEX( pindex) )
continue;
memset( msgbuf, 0, sizeof( msgbuf));
snprintf( msgbuf, sizeof( msgbuf ), "K%d", i );
CHAR_sendStatusString( toindex, msgbuf );
CHAR_send_K_StatusString(toindex, i,CHAR_K_STRING_HP|CHAR_K_STRING_AI);
}
}
return petindex;
}
BOOL PETFUSION_AddEgg( int toindex, int petID, int PetCode)
{
int ret;
char msgbuf[64];
int enemynum;
int i,j;
int petindex, petindex2;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7>п<EFBFBD>λ
for( i = 0 ;i < CHAR_MAXPETHAVE ; i++) {
petindex = CHAR_getCharPet( toindex, i);
if( petindex == -1 )
break;
}
if( i == CHAR_MAXPETHAVE ) {
snprintf( msgbuf,sizeof( msgbuf), "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
CHAR_talkToCli( toindex, -1, msgbuf, CHAR_COLORYELLOW);
return -1;
}
enemynum = ENEMY_getEnemyNum();
for( i = 0; i < enemynum; i ++ ) {//PetCode
if( ENEMY_getInt( i, ENEMY_ID ) == petID )
//if( ENEMY_getInt( i, ENEMY_TEMPNO ) == PetCode )
break;
}
if( i == enemynum ){
print("ANDY err i == enemynum \n");
return -1;
}
ret = ENEMY_createPetFromEnemyIndex( toindex, i);
for( i = 0; i < CHAR_MAXPETHAVE; i ++ ) {
if( CHAR_getCharPet( toindex, i ) == ret )
break;
}
if( i == CHAR_MAXPETHAVE )
i = 0;
if( CHAR_CHECKINDEX( ret ) == TRUE ){
CHAR_setMaxExpFromLevel( ret, CHAR_getInt( ret, CHAR_LV ));
}
petindex2 = CHAR_getCharPet( toindex, i);
if( !CHAR_CHECKINDEX( petindex2) ){
print("ANDY petindex2=%d\n", petindex2);
return -1;
}
CHAR_setInt( petindex2, CHAR_FUSIONINDEX, PetCode);
snprintf( msgbuf,sizeof( msgbuf), "<EFBFBD>õ<EFBFBD>%s<><73>", CHAR_getChar(petindex2,CHAR_NAME));
CHAR_talkToCli( toindex, -1, msgbuf, CHAR_COLORYELLOW);
for(j = 0; j < CHAR_MAXPETHAVE; j++){
petindex = CHAR_getCharPet(toindex, j);
if( !CHAR_CHECKINDEX( petindex) )
continue;
CHAR_complianceParameter( petindex );
snprintf( msgbuf, sizeof( msgbuf ), "K%d", j );
CHAR_sendStatusString( toindex, msgbuf );
snprintf( msgbuf, sizeof( msgbuf ), "W%d", j );
CHAR_sendStatusString( toindex, msgbuf );
}
LogPet(
CHAR_getChar( toindex, CHAR_NAME ),
CHAR_getChar( toindex, CHAR_CDKEY ),
CHAR_getChar( petindex2, CHAR_NAME),
CHAR_getInt( petindex2, CHAR_LV),
"TenseiGet",
CHAR_getInt( toindex,CHAR_FLOOR),
CHAR_getInt( toindex,CHAR_X ),
CHAR_getInt( toindex,CHAR_Y ),
CHAR_getChar( petindex2, CHAR_UNIQUECODE) // shan 2001/12/14
);
return petindex2;
}
#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) )
#ifdef _PETTRANS_RANGE
work[0] += ( RAND(getPetTransRangeX(),getPetTransRangeY()) - getPetTransRangeZ() );
work[1] += ( RAND(getPetTransRangeX(),getPetTransRangeY()) - getPetTransRangeZ() );
work[2] += ( RAND(getPetTransRangeX(),getPetTransRangeY()) - getPetTransRangeZ() );
work[3] += ( RAND(getPetTransRangeX(),getPetTransRangeY()) - getPetTransRangeZ() );
#else
work[0] += ( RAND(0,4) - 2 );
work[1] += ( RAND(0,4) - 2 );
work[2] += ( RAND(0,4) - 2 );
work[3] += ( RAND(0,4) - 2 );
#endif
/* LevelUpPoint = ( work[0] << 24 )
+ (work[1] << 16)
+ (work[2] << 8 )
+ (work[3] << 0 );*/
#ifdef _PET_TRANS_ABILITY
LevelUpPoint
= ((work[0] + getPetTransAbility() * (CHAR_getInt( petindex, CHAR_TRANSMIGRATION)+1)) << 24)
+ ((work[1] + getPetTransAbility() * (CHAR_getInt( petindex, CHAR_TRANSMIGRATION)+1)) << 16)
+ ((work[2] + getPetTransAbility() * (CHAR_getInt( petindex, CHAR_TRANSMIGRATION)+1)) << 8)
+ ((work[3] + getPetTransAbility() * (CHAR_getInt( petindex, CHAR_TRANSMIGRATION)+1)) << 0);
#else
LevelUpPoint
= (work[0] << 24)
+ (work[1] << 16)
+ (work[2] << 8)
+ (work[3] << 0);
#endif
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);
//<2F><><EFBFBD>＼<EFBFBD><EFBCBC><EFBFBD><EFBFBD>Ϊ<EFBFBD>߼<EFBFBD>
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
Reference in New Issue Copy Permalink