char_base.c.bak

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

                  "%s=%s" CHAR_DELIMITER,
                  CHAR_setchardata[i],
                  makeEscapeString( one->string[i].string, escapebuffer,
                                    sizeof( escapebuffer) ));

        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }
    for( i = 0 ; i < arraysizeof( one->flg ) ; i ++ ){
        char    linedata[128];
        snprintf( linedata , sizeof(linedata),
                  FLGRESERVESTRING "%d=%d" CHAR_DELIMITER,
                  i, one->flg[i]);

        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }

    for( i = 0 ; i < CHAR_SKILLMAXHAVE ; i ++ ){
        char    linedata[128];
        char    *skillstring=NULL;
        if( one->haveSkill[i].use == TRUE)
            skillstring = SKILL_makeStringFromSkillData(
                &one->haveSkill[i].skill );
        if( skillstring == NULL ) continue;
        snprintf( linedata , sizeof( linedata ),
                  SKILLRESERVESTRING "%d=%s" CHAR_DELIMITER,
                  i,skillstring );
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }

    for( i = 0 ; i < CHAR_MAXITEMHAVE ; i ++ ){
        char    linedata[2048];
        char    *itemstring=NULL;
        if( one->indexOfExistItems[i] != -1 )
            itemstring = ITEM_makeStringFromItemIndex(
                							one->indexOfExistItems[i], 0);
        if( itemstring == NULL )continue;
        snprintf( linedata , sizeof( linedata ),
                  ITEMRESERVESTRING "%d=%s" CHAR_DELIMITER,
                  i, itemstring);
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );

        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }

    for( i = 0 ; i < CHAR_MAXPOOLITEMHAVE ; i ++ ){
        char    linedata[2048];
        char    *itemstring=NULL;
        if( one->indexOfExistPoolItems[i] != -1 )
            itemstring = ITEM_makeStringFromItemIndex(
                							one->indexOfExistPoolItems[i], 0);
        if( itemstring == NULL )continue;
        snprintf( linedata , sizeof( linedata ),
                  POOLITEMRESERVESTRING "%d=%s" CHAR_DELIMITER,
                  i, itemstring);
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }

    for( i = 0 ; i < CHAR_TITLEMAXHAVE ; i ++ ){
        char    linedata[128];
		if( one->indexOfHaveTitle[i]< 0 || one->indexOfHaveTitle[i] >= CHAR_TITLEMAXHAVE ) {
			continue;
		}
        snprintf( linedata , sizeof( linedata ),
                  TITLERESERVESTRING "%d=%d" CHAR_DELIMITER,
                  i, one->indexOfHaveTitle[i] );
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }
    for( i=0 ; i < ADDRESSBOOK_MAX ; i++ ){
        char    linedata[512];
		char	*p;
		p = ADDRESSBOOK_makeAddressbookString(&one->addressBook[i]);
		if( strlen( p) == 0 ) {
			continue;
		}
        snprintf( linedata ,sizeof(linedata),
                  ADDRESSBOOKRESERVESTRING "%d=%s" CHAR_DELIMITER,
                  i,p
            );
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
    	}
    }
    for( petnum = 0; petnum < CHAR_MAXPETHAVE; petnum ++ ) {
		int	petindex;
		char	linedata[4096*2];
		char	*petstring;
		petindex = one->unionTable.indexOfPet[petnum];
	    if( !CHAR_CHECKINDEX(petindex))continue;
		petstring = CHAR_makePetStringFromPetIndex( petindex);
		if( petstring == NULL ) continue;
        snprintf( linedata , sizeof(linedata),
                  PETSERVERSTRING "%d=%s" CHAR_DELIMITER,petnum,petstring );
        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
		}
	}

    for( petnum = 0; petnum < CHAR_MAXPOOLPETHAVE; petnum ++ ) {
		int	petindex;
		char	linedata[4096*2];
		char	*petstring;
		petindex = one->indexOfPoolPet[petnum];
	    if( !CHAR_CHECKINDEX(petindex))continue;
		petstring = CHAR_makePetStringFromPetIndex( petindex);
		if( petstring == NULL ) continue;

		//andy_log
        if( strstr( petstring, "name:") == NULL ||
			strstr( petstring, "ownt:") == NULL ) {
			LodBadPetString( "petstring", "poolpet string buffer err:", petnum);
			fprint( "ANDY err poolpet string buffer err:\n%s\n", petstring);
        	goto RETURN;
		}

        snprintf( linedata , sizeof(linedata),
                  POOLPETSERVERSTRING "%d=%s" CHAR_DELIMITER,petnum,petstring );

        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( CHAR_dataString ) ) {
			fprint( "err chardata buffer over\n");
        	goto RETURN;
		}
	}
#ifdef _CHAR_FIXDATADEF
	{
		char linedata[1024];
		memset( linedata, 0, sizeof(linedata));
        snprintf( linedata , sizeof(linedata),
                  DATAENDCHECKPOINT "=%d" CHAR_DELIMITER, (int)time(NULL)/1000);

        strcpysafe( &CHAR_dataString[strlength],
                    sizeof( CHAR_dataString ) - strlength, linedata );

		if( strlength > sizeof( CHAR_dataString ) ) {
			LodBadPetString( "DATAENDCHECKPOINT", "err chardata buffer over", -1);
			fprint( "err chardata buffer over:DATAENDCHECKPOINT !\n");
        	goto MAKESTRINGERR;
		}
	}
#endif

RETURN:
	if( strstr( CHAR_dataString, DATAENDCHECKPOINT) == NULL ){
		LodBadPetString( CHAR_dataString, "err mk dataString no end", -1);
	}

    return CHAR_dataString;
MAKESTRINGERR:
	return NULL;
}

char* CHAR_makeStringFromCharIndex( int index )
{
    if( 0 <= index && index <= CHAR_charanum        /*    index OK*/
        && CHAR_chara[index].use == TRUE )
        /* OK */;
    else
        return NULL;
    return CHAR_makeStringFromCharData(&CHAR_chara[index]);

}

BOOL CHAR_makeCharFromStringToArg( char* data, Char* one)
{
    int i;
    int readindex=1, rightData=0;

    if( data[0] == '\0' )
        return FALSE;
DebugPoint=51;
    {    
		char name[4096];
		char *sp = strstr( data, "name=");
		char *sp2 = strstr( data, "ownt=");
		if( sp && sp2 ){
			snprintf( name, sp2-sp-5, "%s", sp+5 );		
			print("\n开始登陆人物名称:%s ", name );
		}else
			print("\n开始登陆人物名称错误! ");
			
		if( data[strlen(data)-2] != '\n' ){
			print("\n 登陆错误!:%s ",data+strlen(data)-20 );
		}
		
		if( strlen(name) > 16 ){
			print("人物名称过长!! 人物名称:%s 长度:%d ", name ,strlen(name) );
		}
    }

    memset( one , 0 , sizeof( Char ));
DebugPoint=52;
    CHAR_getDefaultChar(one, 0);
    // Robin 0726 default RidePet
    one->data[CHAR_RIDEPET] = -1;
	strcpysafe( one->string[CHAR_FMNAME].string,
		sizeof( one->string[CHAR_FMNAME].string), "\0" );
	one->data[CHAR_FMINDEX] = -1;
#ifdef _PETSKILL_BECOMEPIG
    one->data[CHAR_BECOMEPIG] = -1;
	one->data[CHAR_BECOMEPIG_BBI] = 100250;
#endif

DebugPoint=53;
    while( 1 ){
        BOOL    ret;
        char    linebuf[4096];
        char firstToken[256];
        char secondToken[4096];
		memset( linebuf, 0, sizeof( linebuf));
		memset( firstToken, 0, sizeof( firstToken));
		memset( secondToken, 0, sizeof( secondToken));
DebugPoint=54;
        ret = getStringFromIndexWithDelim( data ,CHAR_DELIMITER,
                                           readindex,
                                           linebuf,  sizeof( linebuf ) );
DebugPoint=55;
        if( ret == FALSE )break;
        if( linebuf[0] == '#'   ||
            linebuf[0] == '\n'  ||
            linebuf[0] == '\0' ){           
            readindex ++;
            continue;
        }
DebugPoint=56;
        ret = getStringFromIndexWithDelim( linebuf , "=" ,  1 ,
                                           firstToken ,
                                           sizeof(firstToken) );
        if( ret == FALSE )  return FALSE;
DebugPoint=57;
        strcpysafe( secondToken , sizeof( secondToken ),
                    linebuf + strlen(firstToken) + strlen("=") );
DebugPoint=58;
	    for( i = 0 ; i < CHAR_DATAINTNUM ; i ++ ){
            if( strcmp(firstToken ,CHAR_setintdata[i] ) == 0 ){
                one->data[i] = atoi( secondToken );
                goto NEXT;
            }
        }
DebugPoint=59;
        for( i = 0 ; i < CHAR_DATACHARNUM ; i ++ ){
            if( strcmp( firstToken ,CHAR_setchardata[i] ) == 0 ){
                strcpysafe( one->string[i].string,
                            sizeof(one->string[i].string),
                            makeStringFromEscaped(secondToken) );
				if( strlen( one->string[i].string ) > 128 ){
                	print(" CHARDATA_to_long!!:%s:%d ", one->string[i].string, strlen( one->string[i].string ) );
                	one->string[i].string[0]=0;
                }
                goto NEXT;
            }
        }
DebugPoint=60;
        if( strncmp( firstToken , FLGRESERVESTRING,
                     strlen( FLGRESERVESTRING ) ) == 0 ){
            int     flgindex;
            flgindex = atoi( firstToken+strlen(FLGRESERVESTRING) );
            if( flgindex < 0 || arraysizeof( one->flg ) <=  flgindex )
                ;
            else
                one->flg[flgindex] = atoi( secondToken );

            goto NEXT;
        }
DebugPoint=61;
        if( strncmp( firstToken , ITEMRESERVESTRING,
                     strlen( ITEMRESERVESTRING ) ) == 0 ){
            int itemindex;
            if( strcmp( secondToken, NULLITEM) == 0 )
                goto NEXT;
             itemindex = atoi( firstToken+strlen(ITEMRESERVESTRING) );
            if( itemindex < 0 || CHAR_MAXITEMHAVE <=  itemindex
                ||  one->indexOfExistItems[itemindex] != -1 ){
                 ;
            }else{
                ITEM_Item   itmone;
                BOOL ret;

                ret = ITEM_makeExistItemsFromStringToArg( secondToken, &itmone, 0);

                if( ret == TRUE ){
                    int existitemindex;
                    existitemindex = ITEM_initExistItemsOne( &itmone );
                    one->indexOfExistItems[itemindex] = existitemindex;
                }
            }
            goto NEXT;
        }
DebugPoint=62;
        if( strncmp( firstToken , POOLITEMRESERVESTRING,
                     strlen( POOLITEMRESERVESTRING ) ) == 0 ){
            int itemindex;
            if( strcmp( secondToken, NULLITEM) == 0 )
                goto NEXT;
            itemindex = atoi( firstToken+strlen(POOLITEMRESERVESTRING) );
            if( itemindex < 0 || CHAR_MAXPOOLITEMHAVE <=  itemindex
                ||  one->indexOfExistPoolItems[itemindex] != -1 ){
                ;
            }else{
                ITEM_Item   itmone;
                BOOL ret;
                ret = ITEM_makeExistItemsFromStringToArg( secondToken , &itmone, 0 );

                if( ret == TRUE ){
                    int existitemindex;
                    existitemindex = ITEM_initExistItemsOne( &itmone );
                    one->indexOfExistPoolItems[itemindex] = existitemindex;
                }
            }
            goto NEXT;
        }
DebugPoint=63;
        if( strncmp( firstToken , SKILLRESERVESTRING,
                     strlen( SKILLRESERVESTRING ) ) == 0 ){
            int skillindex;
            if( strcmp( secondToken, NULLSKILL) == 0 )
                goto NEXT;
            skillindex =atoi( firstToken+strlen(SKILLRESERVESTRING) );
            if( skillindex < 0 || CHAR_SKILLMAXHAVE <=  skillindex
                ||  one->haveSkill[skillindex].use == TRUE ){
            }else{
                BOOL    ret;
                Skill   skillone;
                ret=SKILL_makeSkillFromStringToArg(secondToken,&skillone);

                if( ret == TRUE ){
                    memcpy( &one->haveSkill[skillindex].skill , &skillone,
                            sizeof( Skill ));
                    one->haveSkill[skillindex].use = TRUE;
                }
            }
            goto NEXT;
        }
DebugPoint=64;
        if( strncmp( firstToken , TITLERESERVESTRING,
                     strlen( TITLERESERVESTRING ) ) == 0 ){
			int titlenumber=atoi(firstToken+strlen(TITLERESERVESTRING));
            if( titlenumber < 0 || CHAR_TITLEMAXHAVE <= titlenumber ){
            }else{
                int titleindex = atoi( secondToken );
                if( TITLE_getTitleIndex( titleindex) != -1)
                    one->indexOfHaveTitle[titlenumber] = titleindex;
            }
            goto NEXT;
        }
DebugPoint=65;
        if( strncmp( firstToken , ADDRESSBOOKRESERVESTRING,
                     strlen( ADDRESSBOOKRESERVESTRING ) ) == 0 ){
            int addressnumber = atoi( firstToken
                                      +strlen(ADDRESSBOOKRESERVESTRING));
            if( addressnumber < 0 || ADDRESSBOOK_MAX <= addressnumber ){
            }else{
                ADDRESSBOOK_makeAddressbookEntry( secondToken,
                                                  &one
                                                  ->addressBook[
                                                      addressnumber]);
            }
            goto NEXT;
        }
DebugPoint=66;
        if( strncmp( firstToken , PETSERVERSTRING,
                     strlen( PETSERVERSTRING ) ) == 0 ){
			Char	ch;
			int		ret;
			int	petnumber = atoi( firstToken+strlen(PETSERVERSTRING));
			if( !CHAR_CHECKPETINDEX( petnumber)) goto NEXT;
			ret = CHAR_makePetFromStringToArg(secondToken,&ch, petnumber);
			if( ret == TRUE ){
		        int petindex = PET_initCharOneArray( &ch );
		        if( petindex < 0 ){
		        	pri